Example #1
0
        /// <summary>
        ///     And egg has hatched. This can be called from any page
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="hatchedEggResponse"></param>
        /// <returns></returns>
        private void GameClient_OnEggHatched(object sender, GetHatchedEggsResponse hatchedEggResponse)
        {
            Task.Run(new Action(async() =>
            {
                for (var i = 0; i < hatchedEggResponse.PokemonId.Count; i++)
                {
                    GameClient.CurrentSession.Logger.Info("Egg Hatched");

                    var currentPokemon = hatchedEggResponse.HatchedPokemon[i];

                    if (currentPokemon == null)
                    {
                        continue;
                    }

                    await
                    new MessageDialog(string.Format(
                                          Utils.Resources.CodeResources.GetString("EggHatchMessage"),
                                          currentPokemon.PokemonId, hatchedEggResponse.StardustAwarded[i], hatchedEggResponse.CandyAwarded[i],
                                          hatchedEggResponse.ExperienceAwarded[i])).ShowAsyncQueue();

                    if (i == 0)
                    {
                        WindowWrapper.Current().Dispatcher.Dispatch(() =>
                        {
                            BootStrapper.Current.NavigationService.Navigate(typeof(PokemonDetailPage), new SelectedPokemonNavModel()
                            {
                                SelectedPokemonId = currentPokemon.Id.ToString(),
                                ViewMode          = PokemonDetailPageViewMode.ReceivedPokemon
                            });
                        });
                    }
                }
            }));
        }
Example #2
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="mapObjectsResponse"></param>
 /// <param name="hatchedEggsResponse"></param>
 /// <param name="inventoryResponse"></param>
 /// <param name="awardedBadgesResponse"></param>
 /// <param name="downloadSettingsResponse"></param>
 public ResponseContainer(TPrimaryResponse primaryResponse, GetHatchedEggsResponse hatchedEggsResponse,
                          GetInventoryResponse inventoryResponse, CheckAwardedBadgesResponse awardedBadgesResponse,
                          DownloadSettingsResponse downloadSettingsResponse)
 {
     PrimaryResponse          = primaryResponse;
     HatchedEggsResponse      = hatchedEggsResponse;
     InventoryResponse        = inventoryResponse;
     AwardedBadgesResponse    = awardedBadgesResponse;
     DownloadSettingsResponse = downloadSettingsResponse;
 }
Example #3
0
        public static void ProcessGetHatchedEggsResponse(Client client, GetHatchedEggsResponse response)
        {
            if (response.HatchedPokemon.Count == 0)
            {
                return;
            }
            PokemonData hatched   = response.HatchedPokemon[0];
            var         MaxCP     = PokemonGo.RocketAPI.PokemonInfo.CalculateMaxCP(hatched);
            var         Level     = PokemonGo.RocketAPI.PokemonInfo.GetLevel(hatched);
            var         IVPercent = PokemonGo.RocketAPI.PokemonInfo.CalculatePokemonPerfection(hatched).ToString("0.00");

            Logger.ColoredConsoleWrite(ConsoleColor.DarkYellow, $"Hatched a {response.EggKmWalked} Km egg, and we got a " +
                                       $"{hatched.PokemonId} (CP: {hatched.Cp} | MaxCP: {MaxCP} | Level: {Level} | IV: {IVPercent}% )" +
                                       $" [{response.CandyAwarded} candies/{response.StardustAwarded} stardust/{response.ExperienceAwarded} XP]");
        }
Example #4
0
        public static void ProcessGetHatchedEggsResponse(Client client, GetHatchedEggsResponse response)
        {
            if (response == null)
            {
                return;
            }
            // TODO:

            /*
             * response.CandyAwarded;
             * response.EggKmWalked;
             * response.ExperienceAwarded;
             * response.HatchedPokemon;
             * response.PokemonId;
             * response.StardustAwarded;
             */
            Logger.Debug("CandyAwarded:" + response.CandyAwarded);
            Logger.Debug("EggKmWalked:" + response.EggKmWalked);
            Logger.Debug("ExperienceAwarded:" + response.ExperienceAwarded);
            Logger.Debug("HatchedPokemon:" + response.HatchedPokemon);
            Logger.Debug("PokemonId:" + response.PokemonId);
            Logger.Debug("StardustAwarded:" + response.StardustAwarded);
        }
Example #5
0
        protected ByteString GetPlayerPacket(RequestType typ, object msg)
        {
            switch (typ)
            {
            case RequestType.SetFavoritePokemon:
                SetFavoritePokemonResponse sfp = new SetFavoritePokemonResponse();
                SetFavoritePokemonMessage  m   = (SetFavoritePokemonMessage)msg;

                var owned = this.GetPokemonById((ulong)m.PokemonId);
                if (owned != null)
                {
                    m.IsFavorite   = true;
                    owned.favorite = true;
                    this.Database.OwnedPokemons.Update(owned);
                    sfp.Result = SetFavoritePokemonResponse.Types.Result.Success;
                }
                else
                {
                    sfp.Result = SetFavoritePokemonResponse.Types.Result.ErrorPokemonNotFound;
                }

                //this.Log.Dbg($"TypeOfResponseMessage: {nameof(SetFavoritePokemonResponse)}");
                return(sfp.ToByteString());

            case RequestType.LevelUpRewards:
                LevelUpRewardsResponse lur = new LevelUpRewardsResponse();
                lur.Result = LevelUpRewardsResponse.Types.Result.Success;
                lur.ItemsAwarded.AddRange(new RepeatedField <ItemAward>()
                {
                    new ItemAward()
                    {
                        ItemId = ItemId.ItemPokeBall, ItemCount = 2
                    },
                    new ItemAward()
                    {
                        ItemId = ItemId.ItemTroyDisk, ItemCount = 2
                    }
                });
                //this.Log.Dbg($"TypeOfResponseMessage: {nameof(LevelUpRewardsResponse)}");
                return(lur.ToByteString());

            case RequestType.ReleasePokemon:
                ReleasePokemonResponse rp = this.ReleasePokemon((ReleasePokemonMessage)msg);

                //this.Log.Dbg($"TypeOfResponseMessage: {nameof(ReleasePokemonResponse)}");
                return(rp.ToByteString());

            case RequestType.UpgradePokemon:
                UpgradePokemonResponse up = new UpgradePokemonResponse();
                //UpgradePokemonMessage upm = (UpgradePokemonMessage)msg;
                //var uptpkmn = brc.GetPokemonById(upm.PokemonId);
                //if (uptpkmn!=null)
                //{
                //}
                //else
                //{
                //    up.Result = UpgradePokemonResponse.Types.Result.ErrorPokemonNotFound;
                //}

                //this.Log.Dbg($"TypeOfResponseMessage: {nameof(UpgradePokemonResponse)}");
                return(up.ToByteString());

            //https://github.com/msx752/PoGoEmulator/issues/24
            case RequestType.GetPlayerProfile:
                GetPlayerProfileResponse gpp = new GetPlayerProfileResponse();
                gpp.Result    = GetPlayerProfileResponse.Types.Result.Success;
                gpp.StartTime = (long)DateTime.Now.ToUnixTime();
                gpp.Badges.Add(new POGOProtos.Data.PlayerBadge()
                {
                    BadgeType    = BadgeType.BadgeTravelKm,
                    EndValue     = 2674,
                    CurrentValue = 1337
                });
                return(gpp.ToByteString());

            //case RequestType.SetAvatar:
            //    LevelUpRewardsResponse sa = new LevelUpRewardsResponse();
            //    return sa.ToByteString();

            case RequestType.GetPlayer:

                //this.Log.Dbg($"TypeOfResponseMessage: {nameof(GetPlayerResponse)}");
                return(this.GetPlayer());

            case RequestType.GetInventory:
                RepeatedField <InventoryItem> items = new RepeatedField <InventoryItem>();
                //ADD ITEMSS
                GetInventoryResponse gi = new GetInventoryResponse();
                gi.Success        = true;
                gi.InventoryDelta = new POGOProtos.Inventory.InventoryDelta()
                {
                    NewTimestampMs = (long)DateTime.Now.ToUnixTime()
                };
                gi.InventoryDelta.InventoryItems.AddRange(items);

                //this.Log.Dbg($"TypeOfResponseMessage: {nameof(GetInventoryResponse)}");
                return(gi.ToByteString());

            case RequestType.GetAssetDigest:
                var gad = GlobalSettings.GameAssets[this.CurrentPlayer.Platform].Value;

                //this.Log.Dbg($"TypeOfResponseMessage: {nameof(GetAssetDigestResponse)}");
                return(gad.ToByteString());

            //case RequestType.NicknamePokemon:
            //    LevelUpRewardsResponse np = new LevelUpRewardsResponse();
            //    return np.ToByteString();

            case RequestType.GetHatchedEggs:
                GetHatchedEggsResponse ghe = new GetHatchedEggsResponse();
                ghe.Success = true;

                //this.Log.Dbg($"TypeOfResponseMessage: {nameof(GetHatchedEggsResponse)}");
                return(ghe.ToByteString());

            case RequestType.CheckAwardedBadges:
                CheckAwardedBadgesResponse cab = new CheckAwardedBadgesResponse();
                cab.Success = true;

                //this.Log.Dbg($"TypeOfResponseMessage: {nameof(CheckAwardedBadgesResponse)}");
                return(cab.ToByteString());

            //case RequestType.RecycleInventoryItem:
            //    LevelUpRewardsResponse rii = new LevelUpRewardsResponse();
            //    return rii.ToByteString();

            //case RequestType.ClaimCodename:
            //    LevelUpRewardsResponse cc = new LevelUpRewardsResponse();
            //    return cc.ToByteString();

            default:
                throw new Exception($"unknown (Player) Returns type: {typ}");
            }
        }
Example #6
0
        public static void ProcessCommonResponses(Client client, RepeatedField <ByteString> responses, bool processBuddyWalked = true, bool processInBox = true)
        {
            if (responses != null)
            {
                var checkChallengeResponse = new CheckChallengeResponse();
                if (responses.Count > 1)
                {
                    checkChallengeResponse.MergeFrom(responses[1]);
                    CommonRequest.ProcessCheckChallengeResponse(client, checkChallengeResponse);
                }

                var getHatchedEggsResponse = new GetHatchedEggsResponse();
                if (responses.Count > 2)
                {
                    getHatchedEggsResponse.MergeFrom(responses[2]);
                    CommonRequest.ProcessGetHatchedEggsResponse(client, getHatchedEggsResponse);
                }

                var getInventoryResponse = new GetInventoryResponse();
                if (responses.Count > 3)
                {
                    getInventoryResponse.MergeFrom(responses[3]);
                    CommonRequest.ProcessGetInventoryResponse(client, getInventoryResponse);
                }

                var checkAwardedBadgesResponse = new CheckAwardedBadgesResponse();
                if (responses.Count > 4)
                {
                    checkAwardedBadgesResponse.MergeFrom(responses[4]);
                    CommonRequest.ProcessCheckAwardedBadgesResponse(client, checkAwardedBadgesResponse);
                }

                var downloadSettingsResponse = new DownloadSettingsResponse();
                if (responses.Count > 5)
                {
                    downloadSettingsResponse.MergeFrom(responses[5]);
                    CommonRequest.ProcessDownloadSettingsResponse(client, downloadSettingsResponse);
                }
                var index = 5;
                if (processBuddyWalked)
                {
                    index++;
                    var getBuddyWalkedResponse = new GetBuddyWalkedResponse();
                    if (responses.Count > index)
                    {
                        getBuddyWalkedResponse.MergeFrom(responses[index]);
                        CommonRequest.ProcessGetBuddyWalkedResponse(client, getBuddyWalkedResponse);
                    }
                }
                if (processInBox)
                {
                    index++;
                    var getInboxResponse = new GetInboxResponse();

                    if (responses.Count > index)
                    {
                        getInboxResponse.MergeFrom(responses[index]);
                        CommonRequest.ProcessGetInboxResponse(client, getInboxResponse);
                    }
                }
            }
        }
Example #7
0
 private void OnHatchedEggsReceived(object sender, GetHatchedEggsResponse hatchedEggResponse)
 {
     //
 }
Example #8
0
 private void OnHatchedEggsReceived(object sender, GetHatchedEggsResponse hatchedEggResponse)
 {
     ClientManager.LogCaller(new LoggerEventArgs(String.Format("Egg hatched: {0}, Candy awarded: {1}, XP: {2}, Egg km walked: {3:0.00}, Stardust awarded: {4} Eggs: {5}.", hatchedEggResponse.PokemonId, hatchedEggResponse.CandyAwarded, hatchedEggResponse.ExperienceAwarded, hatchedEggResponse.EggKmWalked, hatchedEggResponse.StardustAwarded, hatchedEggResponse.HatchedPokemon.Count), LoggerTypes.HatchedEggs));
 }
 /// <summary>
 /// Provides a safe way to invoke the <see cref="HatchedEggsReceived" /> event.
 /// </summary>
 /// <param name="value"></param>
 public void RaiseHatchedEggsReceived(GetHatchedEggsResponse value) => HatchedEggsReceived?.Invoke(this, value);
Example #10
0
 internal void OnHatchedEggsReceived(GetHatchedEggsResponse getHatchedEggsResponse)
 {
     HatchedEggsReceived?.Invoke(this, new GetHatchedEggsResponse(getHatchedEggsResponse));
 }