public void GetWords(Action <JSONArray> callback)
    {
        if (!IsTokenAvailable())
        {
            AnonymousLogin();
        }

        new LogEventRequest()
        .SetEventKey("GenerateWords")
        .SetEventAttribute("WordLength", "7")
        .SetEventAttribute("Language", LanguageUtils.RealLanguage(LocaliseText.Language))
        .Send((response) => {
            if (!response.HasErrors && response.ScriptData != null)
            {
                _words = response.ScriptData.GetGSDataList("words");

                if (_words != null && callback != null)
                {
                    JSONArray _arr = new JSONArray();

                    foreach (GSData _data in _words)
                    {
                        JSONObject _w = JSONObject.Parse(_data.JSON);
                        _arr.Add(_w);
                    }

                    callback(_arr);
                }
            }
        });
    }
Example #2
0
    public static Font FontForCurrentLanguage(FontStyle fontStyle)
    {
        Font font;

        switch (LanguageUtils.RealLanguage(LocaliseText.Language))
        {
        case "Bulgarian":
        case "Russian":
        case "Serbian":
            if (fontStyle == FontStyle.Bold || fontStyle == FontStyle.BoldAndItalic)
            {
                font = Resources.Load <Font>("RifficFree-Bold");
            }
            else
            {
                font = Resources.Load <Font>("RifficFree-Bold");
            }
            break;

        default:
            if (fontStyle == FontStyle.Bold || fontStyle == FontStyle.BoldAndItalic)
            {
                font = Resources.Load <Font>("Amaranth-Bold");
            }
            else
            {
                font = Resources.Load <Font>("Amaranth-Regular");
            }
            break;
        }

        return(font);
    }
    public void CreateMatch()
    {
        // NOTE - Create challenge with Event request NOT with CreateChallengeRequest!!!
        new LogEventRequest()
        .SetEventKey("CreateChallenge")
        .SetEventAttribute("language", LanguageUtils.RealLanguage(LocaliseText.Language))
        .Send((response) =>
        {
            _challenges.Clear();

            if (_onChallengeDetected != null)
            {
                _onChallengeDetected.OnChallengesListeFetched(_challenges);
            }
        });
    }
Example #4
0
    void CompleteReward()
    {
        var currentLevel = GameManager.Instance.Levels.Selected;
        var points       = currentLevel.Score;

        currentLevel.AddPoints(points);

        GameManager.Instance.Player.AddPoints(points);

        GameManager.Instance.Player.UpdatePlayerPrefs();
        currentLevel.UpdatePlayerPrefs();
        PreferencesFactory.Save();

        UIHelper.SetTextOnChildGameObject(pointsView, "ScoreResult", LocaliseText.Format("LevelCompleted.ScoreDouble", points), true);

        GameObject DoubleButton = GameObjectHelper.GetChildNamedGameObject(pointsView, "DoubleButton", true);

        DoubleButton.SetActive(false);

        GameObject AdsObject = GameObjectHelper.GetChildNamedGameObject(pointsView, "Ads", true);

        AdsObject.SetActive(false);

        GameObject unlockTextObject = GameObjectHelper.GetChildNamedGameObject(pointsView, "UnlockText", true);

        unlockTextObject.SetActive(false);

        GameObject ShareButton = GameObjectHelper.GetChildNamedGameObject(pointsView, "ShareButton", true);

        ShareButton.SetActive(true);

        if (!_multiplayer)
        {
            JSONObject pointsData = new JSONObject();
            pointsData.Add("Level", currentLevel.Number.ToString());
            pointsData.Add("Language", LocaliseText.Language);
            pointsData.Add("RealLanguage", LanguageUtils.RealLanguage(LocaliseText.Language));
            pointsData.Add("Words", JsonUtils.ListToArray(GameController.Instance.GetFoundWords()));
            pointsData.Add("Date", DateTimeUtils.DateTimeToISO8601(UnbiasedTime.Instance.UTCNow()));

            GameSparksManager.Instance.SendPoints(points, "LevelComplete-Double", pointsData);
        }
    }
Example #5
0
        public new void LoadJsonData()
        {
            var path = string.Format("{0}\\{0}_{1}", IdentifierBase, Number);

            if (LanguageUtils.RealLanguage(LocaliseText.Language) == "Bulgarian" ||
                LanguageUtils.RealLanguage(LocaliseText.Language) == "Serbian" ||
                LanguageUtils.RealLanguage(LocaliseText.Language) == "Portuguese" ||
                LanguageUtils.RealLanguage(LocaliseText.Language) == "Russian")
            {
                path = string.Format("{0}\\{1}\\{0}_{2}", IdentifierBase, LanguageUtils.RealLanguage(LocaliseText.Language), Number);
            }

            if (_levelJson == null)
            {
                _levelJson = LoadJsonDataFile(path);
            }
            if (_levelJson != null)
            {
                ParseJsonData(_levelJson);
            }
        }
    public void RefreshChallengesList()
    {
        if (_refreshCoroutine != null)
        {
            StopCoroutine(_refreshCoroutine);
        }

        _challenges.Clear();

        var requestData = new GSRequestData();

        requestData.AddString("Language", LanguageUtils.RealLanguage(LocaliseText.Language));

        var eligibilityCriteria = new GSRequestData();

        GSData _d = new GSData(new Dictionary <string, object>()
        {
            { "Language", LanguageUtils.RealLanguage(LocaliseText.Language) }
        });

        eligibilityCriteria.AddObject("segments", _d);

        new FindChallengeRequest()
        .SetAccessType("PUBLIC")
        .SetShortCode(new List <string> {
            Constants.ChallengeShortCode
        })
        .SetScriptData(requestData)
        .SetEligibility(eligibilityCriteria)
        .Send((secondResponse) =>
        {
            var publicChallenges = secondResponse.ChallengeInstances;
            if (publicChallenges == null || !publicChallenges.Any())
            {
                var challengesData = secondResponse.ScriptData;
                if (challengesData == null)
                {
                    return;
                }
                var dataList = secondResponse.ScriptData.GetGSDataList("challenges");
                if (dataList != null)
                {
                    if (dataList.Count > 0)
                    {
                        var enumerator = dataList.GetEnumerator();
                        while (enumerator.MoveNext())
                        {
                            var current = enumerator.Current;

                            if (current != null)
                            {
                                string username = null;
                                string userId   = null;
                                var challengeId = current.GetString("challengeId");
                                var scriptData  = current.GetGSData("scriptData");

                                if (scriptData != null)
                                {
                                }
                                var challenger = current.GetGSData("challenger");
                                if (challenger != null)
                                {
                                    username = challenger.GetString("name");
                                    userId   = challenger.GetString("id");

                                    if (userId == PreferencesFactory.GetString(Constants.ProfileUserId))
                                    {
                                        continue;
                                    }
                                }

                                var ch = new Challenge
                                {
                                    ChallengeId    = challengeId,
                                    UserName       = username,
                                    UserId         = userId,
                                    AvatarUploadId = "",
                                    ExternalIds    = null
                                };
                                _challenges.Add(ch);
                            }
                        }
                        enumerator.Dispose();
                    }
                }
            }

            List <string> _ignoreChallangeIds = new List <string>();

            var ignoreList = secondResponse.ScriptData.GetGSDataList("ignoreChallanges");
            if (ignoreList != null)
            {
                var challengesIgnoreEnum = ignoreList.GetEnumerator();
                while (challengesIgnoreEnum.MoveNext())
                {
                    var challenge = challengesIgnoreEnum.Current;

                    _ignoreChallangeIds.Add(challenge.GetString("challengeId"));
                }
            }

            if (publicChallenges != null)
            {
                var challengesEnum = publicChallenges.GetEnumerator();
                while (challengesEnum.MoveNext())
                {
                    var challenge = challengesEnum.Current;

                    if (_ignoreChallangeIds.Contains(challenge.ChallengeId))
                    {
                        continue;
                    }

                    var scriptData = challenge.ScriptData;
                    var showInList = true;
                    if (scriptData != null)
                    {
                        var k = scriptData.GetBoolean("showInList");
                        if (k != null)
                        {
                            showInList = (bool)k;
                        }
                    }
                    if (showInList)
                    {
                        var username = challenge.Challenger.Name;
                        var userId   = challenge.Challenger.Id;

                        if (userId == PreferencesFactory.GetString(Constants.ProfileUserId))
                        {
                            continue;
                        }

                        var ch = new Challenge
                        {
                            ChallengeId    = challenge.ChallengeId,
                            UserName       = username,
                            UserId         = userId,
                            AvatarUploadId = challenge.ScriptData.GetString("avatarUploadId"),
                            ExternalIds    = challenge.Challenger.ExternalIds
                        };
                        _challenges.Add(ch);
                    }
                }
                challengesEnum.Dispose();

                if (_onChallengeDetected != null)
                {
                    _onChallengeDetected.OnChallengesListeFetched(_challenges);
                }
            }

            if (ShouldGetChallengesList)
            {
                _refreshCoroutine = CoRoutines.DelayedCallback(_challengeRefreshRate, RefreshChallengesList);
                StartCoroutine(_refreshCoroutine);
            }
        });
    }
Example #7
0
    public virtual void Show(bool isWon, float time, int points = 0, ChallengeManager.GameStates gameState = ChallengeManager.GameStates.Leaved, ChallengeManager.GameStateMessage message = null)
    {
        _multiplayer = GameSparksManager.Instance.GetGameMode() == GameMode.Multi;

        _buttonPurchaseObject = GameObject.Find("PurchaseButton");

        if (_buttonPurchaseObject != null && !_multiplayer)
        {
            _inviteOriginalParent   = _buttonPurchaseObject.transform.parent.gameObject;
            _inviteOriginalPosition = _buttonPurchaseObject.transform.position;

            _inviteButtonObject = gameObject;
            DialogInstance _inviteDialogInstance = gameObject.GetComponent <DialogInstance>();

            GameObjectUtils.MoveObjectToAtIndex(_buttonPurchaseObject, _inviteDialogInstance.Target, 1);
        }

        pointsView      = GameObjectHelper.GetChildNamedGameObject(DialogInstance.gameObject, "PointsView", true);
        shareView       = GameObjectHelper.GetChildNamedGameObject(DialogInstance.gameObject, "SharingView", true);
        multiplayerView = GameObjectHelper.GetChildNamedGameObject(DialogInstance.gameObject, "MultiplayerPointsView", true);

        if (_multiplayer)
        {
            pointsView.SetActive(false);
            multiplayerView.SetActive(true);

            if (gameState == ChallengeManager.GameStates.Won || gameState == ChallengeManager.GameStates.Draw)
            {
                ButtonUtils.PlayWinSound();
            }
            else
            {
                ButtonUtils.PlayLoseSound();
            }
        }
        else
        {
            pointsView.SetActive(true);
            multiplayerView.SetActive(false);

            ButtonUtils.PlayWinSound();
        }

        var currentLevel = GameManager.Instance.Levels.Selected;

        int  coins           = 0;
        bool firstTimePlayed = _multiplayer ? true : currentLevel.ProgressBest < 0.9f;

        LevelManager.Instance.EndLevel();

        this.Coins = coins;

        if (firstTimePlayed && !_multiplayer)
        {
            currentLevel.AddPoints(points);
            currentLevel.ProgressBest = 1.0f;
        }

        if (_multiplayer && gameState == ChallengeManager.GameStates.Lost)
        {
            points *= -1;
        }

        GameObjectHelper.SafeSetActive(GameObjectHelper.GetChildNamedGameObject(DialogInstance.gameObject, "Dialog", true), false);

        Assert.IsTrue(LevelManager.IsActive, "Ensure that you have a LevelManager component attached to your scene.");

        if (coins > 0 && !_multiplayer)
        { // add coins for this level
            currentLevel.AddCoins(coins);
            GameManager.Instance.Player.AddCoins(coins);
        }

        GameManager.Instance.Player.AddPoints(points);

        // update the player coins if necessary
        if (((UpdatePlayerCoins == CopyType.Always) || (UpdatePlayerCoins == CopyType.OnWin && isWon)) && !_multiplayer)
        {
            GameManager.Instance.Player.AddCoins(currentLevel.Coins);
        }

        // show won / lost game objects as appropriate
        GameObjectHelper.SafeSetActive(GameObjectHelper.GetChildNamedGameObject(DialogInstance.gameObject, "Lost", true), !isWon);

        // see if the world or game is won and also if we should unlock the next world / level
        GameObjectHelper.SafeSetActive(GameObjectHelper.GetChildNamedGameObject(DialogInstance.gameObject, "GameWon", true), false);
        GameObjectHelper.SafeSetActive(GameObjectHelper.GetChildNamedGameObject(DialogInstance.gameObject, "WorldWon", true), false);
        GameObjectHelper.SafeSetActive(GameObjectHelper.GetChildNamedGameObject(DialogInstance.gameObject, "LevelWon", true), false);
        GameObjectHelper.SafeSetActive(GameObjectHelper.GetChildNamedGameObject(DialogInstance.gameObject, "Won", true), false);

        GameObject levelName = GameObjectHelper.GetChildNamedGameObject(DialogInstance.gameObject, "LevelName", true);

        if (_multiplayer)
        {
            levelName.GetComponent <Text>().text = LocaliseText.Get("LevelCompleted.Match");
        }
        else
        {
            levelName.GetComponent <Text>().text = LocaliseText.Format("LevelCompleted.LevelName", currentLevel.Number);
        }

        GameObjectHelper.SafeSetActive(levelName, true);

        if (!_multiplayer && isWon)
        {
            GameObjectHelper.SafeSetActive(GameObjectHelper.GetChildNamedGameObject(DialogInstance.gameObject, "Won", true), true);

            // process and update game state - do this last so we can check some bits above.
            GameHelper.ProcessCurrentLevelComplete();
        }

        // set some text based upon the result
        UIHelper.SetTextOnChildGameObject(DialogInstance.gameObject, "AchievementText", LocaliseText.Format(LocalisationBase + ".Achievement", currentLevel.Score, currentLevel.Name));

        // setup stars
        var starsGameObject = GameObjectHelper.GetChildNamedGameObject(DialogInstance.gameObject, "Stars", true);

        GameObjectHelper.SafeSetActive(starsGameObject, ShowStars);
        if (ShowStars && !_multiplayer)
        {
            Assert.IsNotNull(starsGameObject, "GameOver->ShowStars is enabled, but could not find a 'Stars' gameobject. Disable the option or fix the structure.");
            starsGameObject.SetActive(ShowStars);
            var newStarsWon = GetNewStarsWon();
            currentLevel.StarsWon |= newStarsWon;
            var star1WonGameObject = GameObjectHelper.GetChildNamedGameObject(starsGameObject, "Star1", true);
            var star2WonGameObject = GameObjectHelper.GetChildNamedGameObject(starsGameObject, "Star2", true);
            var star3WonGameObject = GameObjectHelper.GetChildNamedGameObject(starsGameObject, "Star3", true);
            StarWon(currentLevel.StarsWon, newStarsWon, star1WonGameObject, 1, coins);
            StarWon(currentLevel.StarsWon, newStarsWon, star2WonGameObject, 2, coins);
            StarWon(currentLevel.StarsWon, newStarsWon, star3WonGameObject, 4, coins);
            GameObjectHelper.SafeSetActive(GameObjectHelper.GetChildNamedGameObject(starsGameObject, "StarWon", true), newStarsWon != 0);
        }

        // set time

        var timeGameObject = GameObjectHelper.GetChildNamedGameObject(DialogInstance.gameObject, "Time", true);

        GameObjectHelper.SafeSetActive(timeGameObject, ShowTime);
        if (!_multiplayer && ShowTime)
        {
            TimeSpan timeSpan = TimeSpan.FromSeconds(time);

            string timeText = LocaliseText.Format("LevelCompleted.Time", timeSpan.Minutes, timeSpan.Seconds);

            Assert.IsNotNull(timeGameObject, "GameOver->ShowTime is enabled, but could not find a 'Time' gameobject. Disable the option or fix the structure.");

            UIHelper.SetTextOnChildGameObject(timeGameObject, "TimeResult", timeText, true);
        }

        if (!_multiplayer && currentLevel.TimeBest < 0.05)
        { // save only first time played
            currentLevel.TimeBest = time;
        }

        // set coins
        if (ShowCoins && coins > 0)
        {
            var coinsGameObject = GameObjectHelper.GetChildNamedGameObject(DialogInstance.gameObject, "Coins", true);
            GameObjectHelper.SafeSetActive(coinsGameObject, ShowCoins);

            Assert.IsNotNull(coinsGameObject, "GameOver->ShowCoins is enabled, but could not find a 'Coins' gameobject. Disable the option or fix the structure.");
            UIHelper.SetTextOnChildGameObject(coinsGameObject, "CoinsResult", coins.ToString(), true);
        }

        if (!_multiplayer)
        {
            if (firstTimePlayed)
            {
                GameObject DoubleButton = GameObjectHelper.GetChildNamedGameObject(pointsView, "DoubleButton", true);
                DoubleButton.SetActive(Reachability.Instance.IsReachable());
            }
            else
            {
                GameObject ShareButton = GameObjectHelper.GetChildNamedGameObject(pointsView, "ShareButton", true);
                ShareButton.SetActive(true);
            }
        }

        // set score
        var scoreGameObject = GameObjectHelper.GetChildNamedGameObject(_multiplayer ? multiplayerView : pointsView, "Score", true);

        GameObjectHelper.SafeSetActive(scoreGameObject, ShowScore);

        if (!firstTimePlayed)
        {
            GameObjectHelper.SafeSetActive(scoreGameObject, false);
        }

        if (!_multiplayer && firstTimePlayed)
        {
            GameObject adsObject  = GameObjectHelper.GetChildNamedGameObject(pointsView, "Ads", true);
            Text       unlockText = GameObjectHelper.GetChildComponentOnNamedGameObject <Text>(pointsView, "UnlockText", true);

            if (LevelController.Instance.LastLevelInPack(currentLevel))
            {
                Pack pack     = LevelController.Instance.PackForLevel(currentLevel);
                Pack nextPack = LevelController.Packs().GetItem(pack.Number + 1);

                if (nextPack)
                {
                    nextPack.LoadData();

                    adsObject.SetActive(false);
                    unlockText.gameObject.SetActive(true);

                    unlockText.text = LocaliseText.Format("LevelCompleted.LastLevelInPack", LocaliseText.Get(nextPack.JsonData.GetString("name")));
                }
            }

            if (LevelController.Instance.LastLevelInRank(currentLevel))
            {
                Rank rank     = LevelController.Instance.RankForLevel(currentLevel);
                Rank nextRank = LevelController.Ranks().GetItem(rank.Number + 1);

                if (nextRank)
                {
                    nextRank.LoadData();

                    adsObject.SetActive(false);
                    unlockText.gameObject.SetActive(true);

                    unlockText.text = LocaliseText.Format("LevelCompleted.LastLevelInRank", LocaliseText.Get(nextRank.JsonData.GetString("name")));
                }
            }
        }

        if (ShowScore)
        {
            Assert.IsNotNull(scoreGameObject, "GameOver->ShowScore is enabled, but could not find a 'Score' gameobject. Disable the option or fix the structure.");

            UIHelper.SetTextOnChildGameObject(scoreGameObject, "ScoreResult", LocaliseText.Format("LevelCompleted.Score", "0"), true);

            AnimateScoreText(points);
        }

        if (_multiplayer)
        {
            var resultStateObject = GameObjectHelper.GetChildNamedGameObject(multiplayerView, "ResultState", true);
            GameObjectHelper.SafeSetActive(resultStateObject, true);

            string text = "";

            switch (gameState)
            {
            case ChallengeManager.GameStates.Won:
                text = LocaliseText.Get("Game.YouWon");
                break;

            case ChallengeManager.GameStates.Lost:
                text = LocaliseText.Get("Game.YouLost");
                break;

            case ChallengeManager.GameStates.Draw:
                text = LocaliseText.Get("Game.ItsDrawn");
                break;
            }

            resultStateObject.GetComponent <Text>().text = text;
        }

        if (!_multiplayer)
        {
            UpdateNeededCoins();

            LevelController.Instance.PackProgressCompleted(currentLevel);
            UnlockNextLevel();

            //

            int StartupLevels = ((CustomGameManager)CustomGameManager.Instance).StartupLevels;

            if (StartupLevels == currentLevel.Number)
            {
                GameObject adsObject = GameObjectHelper.GetChildNamedGameObject(pointsView, "Ads", true);

                Text adsText = adsObject.GetComponent <Text>();

                adsText.text                 = LocaliseText.Get("Text.PlayedAllLevels");
                adsText.fontSize             = 39;
                adsText.resizeTextForBestFit = false;

                if (!Debug.isDebugBuild)
                {
                    Flurry.Flurry.Instance.LogEvent("Game_LastLevel", new Dictionary <string, string>()
                    {
                        { "Level", currentLevel.Number.ToString() }
                    });
                    Fabric.Answers.Answers.LogCustom("Game_LastLevel", new Dictionary <string, object>()
                    {
                        { "Level", currentLevel.Number.ToString() }
                    });
                }
            }
        }

        if (!_multiplayer && firstTimePlayed)
        {
            JSONObject pointsData = new JSONObject();
            pointsData.Add("Level", currentLevel.Number.ToString());
            pointsData.Add("Language", LocaliseText.Language);
            pointsData.Add("RealLanguage", LanguageUtils.RealLanguage(LocaliseText.Language));
            pointsData.Add("Time", time.ToString());
            pointsData.Add("UsedHints", GameController.Instance.usedHintsCount);
            pointsData.Add("UserCoins", GameManager.Instance.Player.Coins);
            pointsData.Add("Words", JsonUtils.ListToArray(GameController.Instance.GetFoundWords()));
            pointsData.Add("Date", DateTimeUtils.DateTimeToISO8601(UnbiasedTime.Instance.UTCNow()));

            GameSparksManager.Instance.SendPoints(points, "LevelComplete", pointsData);
        }

        //

        GameObject completeTextGameObject = GameObjectHelper.GetChildNamedGameObject(_multiplayer ? multiplayerView : pointsView, "CompleteText", true);

        // save game state.
        GameManager.Instance.Player.UpdatePlayerPrefs();

        if (!_multiplayer)
        {
            currentLevel.UpdatePlayerPrefs();
        }

        PreferencesFactory.Save();

        GameObject NameContainer = GameObjectHelper.GetChildNamedGameObject(DialogInstance.Content, "NameContainer", true);
        GameObject LevelName     = GameObjectHelper.GetChildNamedGameObject(DialogInstance.Content, "LevelName", true);
        GameObject Results       = GameObjectHelper.GetChildNamedGameObject(DialogInstance.Content, "Results", true);
        GameObject Buttons       = GameObjectHelper.GetChildNamedGameObject(DialogInstance.Content, "Buttons", true);
        GameObject CloseButton   = GameObjectHelper.GetChildNamedGameObject(DialogInstance.Content, "Close", true);

        GameObject parent = DialogInstance.Content.transform.parent.gameObject;

        Vector3 currentScale = parent.transform.localScale;

        parent.transform.DOScale(new Vector3(0, 0, 0), 0.0f);
        NameContainer.transform.localScale          = new Vector3(0, 0, 0);
        LevelName.transform.localScale              = new Vector3(0, 0, 0);
        Results.transform.localScale                = new Vector3(0, 0, 0);
        Buttons.transform.localScale                = new Vector3(0, 0, 0);
        completeTextGameObject.transform.localScale = new Vector3(0, 0, 0);

        CloseButton.GetComponent <Image>().color = new Color(1, 1, 1, 0);

        //show dialog
        DialogInstance.Show();

        parent.transform.DOScale(currentScale, 1.0f).SetEase(Ease.OutElastic);
        NameContainer.transform.DOScale(new Vector3(1, 1, 1), 1.5f).SetDelay(0.1f).SetEase(Ease.OutElastic);
        LevelName.transform.DOScale(new Vector3(1, 1, 1), 0.8f).SetDelay(0.2f).SetEase(Ease.OutElastic);
        Results.transform.DOScale(new Vector3(1, 1, 1), 0.8f).SetDelay(0.2f).SetEase(Ease.OutElastic);
        Buttons.transform.DOScale(new Vector3(1, 1, 1), 0.8f).SetDelay(0.2f).SetEase(Ease.OutElastic);
        completeTextGameObject.transform.DOScale(new Vector3(1, 1, 1), 0.8f).SetDelay(0.35f).SetEase(Ease.OutElastic);

        CloseButton.GetComponent <Image>().DOFade(1, 0.5f).SetDelay(0.7f);

        GameObject Light = GameObjectHelper.GetChildNamedGameObject(completeTextGameObject, "Light", true);

        Light.transform.DOLocalRotate(new Vector3(0, 0, -360), 10, RotateMode.LocalAxisAdd).SetLoops(-1).SetEase(Ease.Linear);

        //TODO bug - as we increase TimesPlayedForRatingPrompt on both game start (GameManager) and level finish we can miss this comparison.
        if (GameManager.Instance.TimesPlayedForRatingPrompt == TimesPlayedBeforeRatingPrompt)
        {
            GameFeedback gameFeedback = new GameFeedback();
            gameFeedback.GameFeedbackAssumeTheyLikeOptional();
        }

#if UNITY_ANALYTICS
        // record some analytics on the level played
        if (!_multiplayer)
        {
            var values = new Dictionary <string, object>
            {
                { "score", currentLevel.Score },
                { "Coins", coins },
                { "time", time },
                { "level", currentLevel.Number }
            };
            Analytics.CustomEvent("LevelCompleted", values);
        }
#endif

#if UNITY_EDITOR
        if (!_multiplayer)
        {
            GameSparksManager.Instance.SyncProgressCoroutine();
        }
#endif

#if !UNITY_EDITOR
        AdColonyManager.Instance.RequestAd();
        AdColonyManager.Instance.RequestAd(Constants.AdColonyDoubleCoins);

        LoadInterstitialAd();
        LoadAdmobRewarderVideo();
#endif

        // co routine to periodic updates of display (don't need to do this every frame)
        if (!Mathf.Approximately(PeriodicUpdateDelay, 0))
        {
            StartCoroutine(PeriodicUpdate());
        }
    }