public override void LoadPlayerCenteredScores(LoadScoreCompletion _onCompletion)
        {
            base.LoadPlayerCenteredScores(_onCompletion);

            // Load scores
            EditorGameCenter.Instance.LoadPlayerCenteredScores(this);
        }
		public override	void LoadPlayerCenteredScores (LoadScoreCompletion _onCompletion)
		{
			base.LoadPlayerCenteredScores(_onCompletion);

			// Load scores
			EditorGameCenter.Instance.LoadPlayerCenteredScores(this);
		}
Пример #3
0
        public override void LoadTopScores(LoadScoreCompletion _onCompletion)
        {
            Range _range = new Range(1, MaxResults);

            // Load scores
            LoadScores(_range, _onCompletion);
        }
Пример #4
0
        public override void LoadTopScores(LoadScoreCompletion _onCompletion)
        {
            // Request for top scores
            Range _range = new Range(1, MaxResults);

            LoadScores(_range, _onCompletion);
        }
Пример #5
0
        public override void LoadPlayerCenteredScores(LoadScoreCompletion _onCompletion)
        {
            // Cache callback
            m_loadScoreCompletionCallback = _onCompletion;

            // Load scores
            EditorGameCenter.Instance.LoadPlayerCenteredScores(this, LoadScoreRequestFinished);
        }
		public override	void LoadPlayerCenteredScores (LoadScoreCompletion _onCompletion)
		{
			// Cache callback
			m_loadScoreCompletionCallback	= _onCompletion;
			
			// Load scores
			EditorGameCenter.Instance.LoadPlayerCenteredScores(this, LoadScoreRequestFinished);
		}
Пример #7
0
        public override void LoadMoreScores(eLeaderboardPageDirection _pageDirection, LoadScoreCompletion _onCompletion)
        {
            // Cache callback
            m_loadScoreCompletionCallback = _onCompletion;

            // Load scores
            EditorGameCenter.Instance.LoadMoreScores(this, _pageDirection, LoadScoreRequestFinished);
        }
Пример #8
0
        public override void LoadTopScores(LoadScoreCompletion _onCompletion)
        {
            base.LoadTopScores(_onCompletion);

            // Initiate a request for retreiving top set of scores
            Range _range = new Range(1, MaxResults);

            LoadScores(_range);
        }
Пример #9
0
        private void LoadScores(Range _range, LoadScoreCompletion _onCompletion)
        {
            // Cache properties
            m_range = _range;
            SetLoadScoreFinishedEvent(_onCompletion);

            // Load scores
            loadScores(GetLeaderboardInfoJSONObject().ToJSON());
        }
Пример #10
0
        public override void LoadPlayerCenteredScores(LoadScoreCompletion _onCompletion)
        {
            // Cache original callback
            m_loadPlayerCenteredScoreCompletionCallback = _onCompletion;

            // Initiate a request to load local user score
            Range _range = new Range(1, 1);

            CacheLoadScoreCompletionCallback(OnLocalUserScoreReceived);
            LoadScores(_range);
        }
Пример #11
0
        private void LoadUserInfo(LoadScoreCompletion _onCompletion)
        {
            IScore[] _gcScoreList  = m_leaderboardData.scores;
            int      _gcScoreCount = _gcScoreList.Length;
            Dictionary <string, IScore> _gcUserIDScoreMap = new Dictionary <string, IScore>(_gcScoreCount);

            for (int _iter = 0; _iter < _gcScoreCount; _iter++)
            {
                IScore _curScore = _gcScoreList[_iter];

                // Add entries to user id score map
                _gcUserIDScoreMap.Add(_curScore.userID, _curScore);
            }

            // Now load users
            NPBinding.GameServices.LoadUsers(_gcUserIDScoreMap.Keys.ToArray(), (User[] _userList) => {
                if (_userList == null)
                {
                    if (_onCompletion != null)
                    {
                        _onCompletion(null, null);
                    }

                    return;
                }
                else
                {
                    Score[]         _finalScoreList = new iOSScore[_gcScoreCount];

                    for (int _iter = 0; _iter < _gcScoreCount; _iter++)
                    {
                        User _curUser     = _userList[_iter];
                        IScore _userScore = _gcUserIDScoreMap[_curUser.Identifier];

                        // Add score and user info
                        _finalScoreList[_iter] = new iOSScore(_userScore, _curUser);
                    }

                    // Set new values
                    Scores         = _finalScoreList;
                    LocalUserScore = new iOSScore(m_leaderboardData.localUserScore, NPBinding.GameServices.LocalUser);

                    // Trigger callback
                    if (_onCompletion != null)
                    {
                        _onCompletion(Scores, LocalUserScore);
                    }

                    return;
                }
            });
        }
Пример #12
0
        private void LoadScores(Range _range, LoadScoreCompletion _onCompletion)
        {
            // Set Leaderboard properties
            m_leaderboardData.range = _range;

            // Load scores
            m_leaderboardData.LoadScores((bool _success) => {
                if (_success)
                {
                    LoadUserInfo(_onCompletion);
                    return;
                }
                else
                {
                    if (_onCompletion != null)
                    {
                        _onCompletion(null, null);
                    }

                    return;
                }
            });
        }
Пример #13
0
        public override void LoadPlayerCenteredScores(LoadScoreCompletion _onCompletion)
        {
            Range _range = new Range(1, 1);

            // Set leaderboard properties
            m_leaderboardData.range = _range;

            // Load local players scores
            m_leaderboardData.LoadScores((bool _status) => {
                if (_status)
                {
                    if (m_leaderboardData.localUserScore == null)
                    {
                        LoadTopScores(_onCompletion);
                        return;
                    }
                    else
                    {
                        int _localPlayerRank       = m_leaderboardData.localUserScore.rank;
                        int _maxResults            = MaxResults;
                        int _loadFrom              = Mathf.Max(1, _localPlayerRank - Mathf.FloorToInt(_maxResults * 0.5f));
                        Range _playerCenteredRange = new Range(_loadFrom, _maxResults);

                        // Load scores player centered scores
                        LoadScores(_playerCenteredRange, _onCompletion);
                        return;
                    }
                }
                else
                {
                    if (_onCompletion != null)
                    {
                        _onCompletion(null, null);
                    }
                }
            });
        }
Пример #14
0
        public override void LoadPlayerCenteredScores(LoadScoreCompletion _onCompletion)
        {
            Range _range = new Range(1, 1);

            // First get local player score
            LoadScores(_range, (Score[] _scores, Score _localUserScore, string _error) => {
                // Check if data is valid
                if (_localUserScore == null)
                {
                    LoadScoresFinished(null, null, _error);
                }
                else
                {
                    int _localPlayerRank       = LocalUserScore.Rank;
                    int _maxResults            = MaxResults;
                    int _loadFrom              = Mathf.Max(1, _localPlayerRank - Mathf.FloorToInt(_maxResults * 0.5f));
                    Range _playerCenteredRange = new Range(_loadFrom, _maxResults);

                    // Load scores player centered scores
                    LoadScores(_playerCenteredRange, _onCompletion);
                    return;
                }
            });
        }
		public override	void LoadPlayerCenteredScores (LoadScoreCompletion _onCompletion)
		{
			Range 		_range			= new Range(1, 1);
			
			// Set leaderboard properties
			m_leaderboardData.range		= _range;
			
			// Load local players scores
			m_leaderboardData.LoadScores((bool _status)=>{
				if (_status)
				{
					if (m_leaderboardData.localUserScore == null)
					{
						LoadTopScores(_onCompletion);
						return;
					}
					else
					{
						int 	_localPlayerRank		= m_leaderboardData.localUserScore.rank;
						int		_maxResults				= MaxResults;
						int 	_loadFrom				= Mathf.Max(1, _localPlayerRank - Mathf.FloorToInt(_maxResults * 0.5f));
						Range	_playerCenteredRange	= new Range(_loadFrom, _maxResults);
						
						// Load scores player centered scores
						LoadScores(_playerCenteredRange, _onCompletion);
						return;
					}
				}
				else
				{
					if (_onCompletion != null)
						_onCompletion(null, null);
				}
			});
		}
		/// <summary>
		/// Asynchronously loads the player-centered scores.
		/// </summary>
		/// <param name="_onCompletion">Callback to be called when score results are retrieved from the game service server.</param>
		public virtual	void LoadPlayerCenteredScores (LoadScoreCompletion _onCompletion)
		{
			// Cache callback information
			LoadScoreFinishedEvent	= _onCompletion;
		}
Пример #17
0
        public override void LoadMoreScores(eLeaderboardPageDirection _pageDirection, LoadScoreCompletion _onCompletion)
        {
            Range _curRange = m_leaderboardData.range;

            if (_curRange.from == 0)
            {
                LoadTopScores(_onCompletion);
                return;
            }

            // Based on page direction, compute range of score to be loaded
            int   _maxResults = MaxResults;
            Range _newRange   = new Range(0, _maxResults);

            if (_pageDirection == eLeaderboardPageDirection.PREVIOUS)
            {
                if (_curRange.from == 1)
                {
                    if (_onCompletion != null)
                    {
                        _onCompletion(null, null);
                    }

                    return;
                }

                // Set range start value
                _newRange.from = Mathf.Max(1, _curRange.from - _maxResults);
            }
            else if (_pageDirection == eLeaderboardPageDirection.NEXT)
            {
                // Set range start value
                _newRange.from = _curRange.from + _maxResults;
            }

            // Load scores
            LoadScores(_newRange, _onCompletion);
        }
Пример #18
0
        public override void LoadMoreScores(eLeaderboardPageDirection _pageDirection, LoadScoreCompletion _onCompletion)
        {
            base.LoadMoreScores(_pageDirection, _onCompletion);

            // Calculate score set to be retrieved
            Range _curRange   = m_range;
            int   _maxResults = MaxResults;
            Range _newRange   = new Range(0, _maxResults);

            if (_pageDirection == eLeaderboardPageDirection.PREVIOUS)
            {
                if (_curRange.from == 1)
                {
                    LoadScoresFinished(null, null, "The operation could not be completed because there are no entries available to load.");
                    return;
                }

                _newRange.from = Mathf.Max(1, _curRange.from - _maxResults);
            }
            else if (_pageDirection == eLeaderboardPageDirection.NEXT)
            {
                _newRange.from = Mathf.Max(1, _curRange.from + _curRange.count);
            }

            // Initiate request to load specified score set
            LoadScores(_newRange);
        }
		public override	void LoadPlayerCenteredScores (LoadScoreCompletion _onCompletion)
		{
			base.LoadPlayerCenteredScores(_onCompletion);
			GameServicesAndroid.Plugin.Call(GameServicesAndroid.Native.Methods.LOAD_PLAYER_CENTERED_SCORES, GetInstanceID(),Identifier, GetTimeScopeString(), GetUserScopeString(), MaxResults);						
		}
Пример #20
0
        public override void LoadPlayerCenteredScores(LoadScoreCompletion _onCompletion)
        {
            AndroidLeaderboardsManager _leaderboardsManager = GetLeaderboardManager();

            _leaderboardsManager.LoadPlayerCenteredScores(this, MaxResults, _onCompletion);
        }
Пример #21
0
 /// <summary>
 /// Asynchronously loads an additional set of scores.
 /// </summary>
 /// <param name="_pageDirection">The direction of pagination over leaderboard score sets.</param>
 /// <param name="_onCompletion">Callback that will be called after operation is completed.</param>
 public virtual void LoadMoreScores(eLeaderboardPageDirection _pageDirection, LoadScoreCompletion _onCompletion)
 {
     // Cache callback information
     LoadScoreFinishedEvent = _onCompletion;
 }
		public override	void LoadPlayerCenteredScores (LoadScoreCompletion _onCompletion)
		{
			AndroidLeaderboardsManager _leaderboardsManager = GetLeaderboardManager();			
			_leaderboardsManager.LoadPlayerCenteredScores(this, MaxResults, _onCompletion);
			 
		}
		private void LoadScores (Range _range, LoadScoreCompletion _onCompletion)
		{
			// Set Leaderboard properties
			m_leaderboardData.range	= _range;

			// Load scores
			m_leaderboardData.LoadScores((bool _success)=>{
				
				if (_success)
				{
					LoadUserInfo(_onCompletion);
					return;
				}
				else
				{
					if (_onCompletion != null)
						_onCompletion(null, null);
					
					return;
				}
			});
		}
Пример #24
0
        public override void LoadMoreScores(eLeaderboardPageDirection _pageDirection, LoadScoreCompletion _onCompletion)
        {
            // Check if user has requested for initial score info
            Range _curRange = m_range;

            if (_curRange.from == 0)
            {
                LoadTopScores(_onCompletion);
                return;
            }

            // Based on page direction, compute range of score to be loaded
            int   _maxResults = MaxResults;
            Range _newRange   = new Range(0, _maxResults);

            if (_pageDirection == eLeaderboardPageDirection.PREVIOUS)
            {
                if (_curRange.from == 1)
                {
                    LoadScoresFinished(null, null, "The operation could not be completed because there are no entries available to load.");
                    return;
                }

                // Set range start value
                _newRange.from = Mathf.Max(1, _curRange.from - _maxResults);
            }
            else if (_pageDirection == eLeaderboardPageDirection.NEXT)
            {
                // Set range start value
                _newRange.from = _curRange.from + _maxResults;
            }

            // Load scores
            LoadScores(_newRange, _onCompletion);
        }
		public override	void LoadMoreScores (eLeaderboardPageDirection _pageDirection, LoadScoreCompletion _onCompletion)
		{
			AndroidLeaderboardsManager _leaderboardsManager = GetLeaderboardManager();
			_leaderboardsManager.LoadMoreScores(this, MaxResults, _pageDirection, _onCompletion);
		
		}
		protected void SetLoadScoreFinishedEvent (LoadScoreCompletion _onCompletion)
		{
			LoadScoreFinishedEvent	= _onCompletion;
		}
		/// <summary>
		/// Asynchronously loads an additional score data.
		/// </summary>
		/// <param name="_pageDirection">The direction of pagination.</param>
		/// <param name="_onCompletion">Callback to be called when score results are retrieved from the game service server.</param>
		public virtual void LoadMoreScores (eLeaderboardPageDirection _pageDirection, LoadScoreCompletion _onCompletion)
		{
			// Cache callback information
			LoadScoreFinishedEvent	= _onCompletion;
		}
		public override	void LoadMoreScores (eLeaderboardPageDirection _pageDirection, LoadScoreCompletion _onCompletion)
		{
			// Cache callback
			m_loadScoreCompletionCallback	= _onCompletion;
			
			// Load scores
			EditorGameCenter.Instance.LoadMoreScores(this, _pageDirection, LoadScoreRequestFinished);
		}
Пример #29
0
 /// <summary>
 /// Asynchronously loads the player-centered set of scores.
 /// </summary>
 /// <param name="_onCompletion">Callback that will be called after operation is completed.</param>
 public virtual void LoadPlayerCenteredScores(LoadScoreCompletion _onCompletion)
 {
     // Cache callback information
     LoadScoreFinishedEvent = _onCompletion;
 }
		public override	void LoadMoreScores (eLeaderboardPageDirection _pageDirection, LoadScoreCompletion _onCompletion)
		{
			base.LoadMoreScores(_pageDirection, _onCompletion);

			// Load scores
			EditorGameCenter.Instance.LoadMoreScores(this, _pageDirection);
		}
Пример #31
0
 protected void CacheLoadScoreCompletionCallback(LoadScoreCompletion _onCompletion)
 {
     LoadScoreFinishedEvent = _onCompletion;
 }
Пример #32
0
 /// <summary>
 /// Asynchronously loads an additional score data.
 /// </summary>
 /// <param name="_pageDirection">The direction of pagination.</param>
 /// <param name="_onCompletion">Callback to be called when score results are retrieved from the game service server.</param>
 public abstract void LoadMoreScores(eLeaderboardPageDirection _pageDirection, LoadScoreCompletion _onCompletion);
Пример #33
0
        public override void LoadMoreScores(eLeaderboardPageDirection _pageDirection, LoadScoreCompletion _onCompletion)
        {
            AndroidLeaderboardsManager _leaderboardsManager = GetLeaderboardManager();

            _leaderboardsManager.LoadMoreScores(this, MaxResults, _pageDirection, _onCompletion);
        }
		public override	void LoadMoreScores (eLeaderboardPageDirection _pageDirection, LoadScoreCompletion _onCompletion)
		{
			// Check if user has requested for initial score info
			Range		_curRange		= m_range;

			if (_curRange.from == 0)
			{
				LoadTopScores(_onCompletion);
				return;
			}
			
			// Based on page direction, compute range of score to be loaded
			int			_maxResults		= MaxResults;
			Range		_newRange		= new Range(0, _maxResults);
			
			if (_pageDirection == eLeaderboardPageDirection.PREVIOUS)
			{
				if (_curRange.from == 1)
				{
					LoadScoresFinished(null, null, "The operation could not be completed because there are no entries available to load.");
					return;
				}
				
				// Set range start value
				_newRange.from	= Mathf.Max(1, _curRange.from - _maxResults);
			}
			else if (_pageDirection == eLeaderboardPageDirection.NEXT)
			{
				// Set range start value
				_newRange.from	= _curRange.from + _maxResults;
			}
			
			// Load scores
			LoadScores(_newRange, _onCompletion);
		} 
		public override	void LoadMoreScores (eLeaderboardPageDirection _pageDirection, LoadScoreCompletion _onCompletion)
		{
			base.LoadMoreScores(_pageDirection, _onCompletion);
			GameServicesAndroid.Plugin.Call(GameServicesAndroid.Native.Methods.LOAD_MORE_SCORES, GetInstanceID(), Identifier, (int)_pageDirection, MaxResults);	
		}
		public override	void LoadMoreScores (eLeaderboardPageDirection _pageDirection, LoadScoreCompletion _onCompletion)
		{
			Range		_curRange		= m_leaderboardData.range;

			if (_curRange.from == 0)
			{
				LoadTopScores(_onCompletion);
				return;
			}
			
			// Based on page direction, compute range of score to be loaded
			int			_maxResults		= MaxResults;
			Range		_newRange		= new Range(0, _maxResults);
			
			if (_pageDirection == eLeaderboardPageDirection.PREVIOUS)
			{
				if (_curRange.from == 1)
				{
					if (_onCompletion != null)
						_onCompletion(null, null);

					return;
				}
				
				// Set range start value
				_newRange.from	= Mathf.Max(1, _curRange.from - _maxResults);
			}
			else if (_pageDirection == eLeaderboardPageDirection.NEXT)
			{
				// Set range start value
				_newRange.from	= _curRange.from + _maxResults;
			}
			
			// Load scores
			LoadScores(_newRange, _onCompletion);
		} 
		/// <summary>
		/// Asynchronously loads the player-centered scores.
		/// </summary>
		/// <param name="_onCompletion">Callback to be called when score results are retrieved from the game service server.</param>
		public abstract	void LoadPlayerCenteredScores (LoadScoreCompletion _onCompletion);
		public override	void LoadTopScores (LoadScoreCompletion _onCompletion)
		{
			// Request for top scores
			Range 		_range		= new Range(1, MaxResults);
			
			LoadScores(_range, _onCompletion);
		}
Пример #39
0
 /// <summary>
 /// Asynchronously loads the player-centered scores.
 /// </summary>
 /// <param name="_onCompletion">Callback to be called when score results are retrieved from the game service server.</param>
 public abstract void LoadPlayerCenteredScores(LoadScoreCompletion _onCompletion);
		private void LoadUserInfo (LoadScoreCompletion _onCompletion)
		{
			IScore[]					_gcScoreList		= m_leaderboardData.scores;
			int 						_gcScoreCount		= _gcScoreList.Length;
			Dictionary<string, IScore>	_gcUserIDScoreMap	= new Dictionary<string, IScore>(_gcScoreCount);
			
			for (int _iter = 0; _iter < _gcScoreCount; _iter++)
			{
				IScore			_curScore		= _gcScoreList[_iter];
				
				// Add entries to user id score map
				_gcUserIDScoreMap.Add(_curScore.userID, _curScore);
			}
			
			// Now load users
			NPBinding.GameServices.LoadUsers(_gcUserIDScoreMap.Keys.ToArray(), (User[] _userList)=>{
				
				if (_userList == null)
				{
					if (_onCompletion != null)
						_onCompletion(null, null);

					return;
				}
				else
				{
					Score[]		_finalScoreList	= new iOSScore[_gcScoreCount];
					
					for (int _iter = 0; _iter < _gcScoreCount; _iter++)
					{
						User		_curUser	= _userList[_iter];
						IScore		_userScore	= _gcUserIDScoreMap[_curUser.Identifier];
						
						// Add score and user info
						_finalScoreList[_iter]	= new iOSScore(_userScore, _curUser);
					}
					
					// Set new values
					Scores 						= _finalScoreList;
					LocalUserScore				= new iOSScore(m_leaderboardData.localUserScore, NPBinding.GameServices.LocalUser);

					// Trigger callback
					if (_onCompletion != null)
						_onCompletion(Scores, LocalUserScore);

					return;
				}
			});
		}
		/// <summary>
		/// Asynchronously loads the top scores.
		/// </summary>
		/// <param name="_onCompletion">Callback to be called when score results are retrieved from the game service server.</param>
		public abstract	void LoadTopScores (LoadScoreCompletion _onCompletion);
Пример #42
0
 protected void SetLoadScoreFinishedEvent(LoadScoreCompletion _onCompletion)
 {
     LoadScoreFinishedEvent = _onCompletion;
 }
		/// <summary>
		/// Asynchronously loads an additional score data.
		/// </summary>
		/// <param name="_pageDirection">The direction of pagination.</param>
		/// <param name="_onCompletion">Callback to be called when score results are retrieved from the game service server.</param>
		public abstract	void LoadMoreScores (eLeaderboardPageDirection _pageDirection, LoadScoreCompletion _onCompletion);
Пример #44
0
 /// <summary>
 /// Asynchronously loads the top scores.
 /// </summary>
 /// <param name="_onCompletion">Callback to be called when score results are retrieved from the game service server.</param>
 public abstract void LoadTopScores(LoadScoreCompletion _onCompletion);
		public override	void LoadPlayerCenteredScores (LoadScoreCompletion _onCompletion)
		{
			Range 		_range		= new Range(1, 1);

			// First get local player score
			LoadScores(_range, (Score[] _scores, Score _localUserScore, string _error)=>{

				// Check if data is valid
				if (_localUserScore == null)
				{
					LoadScoresFinished(null, null, _error);
				}
				else
				{
					int 	_localPlayerRank		= LocalUserScore.Rank;
					int		_maxResults				= MaxResults;
					int 	_loadFrom				= Mathf.Max(1, _localPlayerRank - Mathf.FloorToInt(_maxResults * 0.5f));
					Range	_playerCenteredRange	= new Range(_loadFrom, _maxResults);
					
					// Load scores player centered scores
					LoadScores(_playerCenteredRange, _onCompletion);
					return;
				}
			});
		}
		public override	void LoadTopScores (LoadScoreCompletion _onCompletion)
		{
			Range 		_range			= new Range(1, MaxResults);
			
			// Load scores
			LoadScores(_range, _onCompletion);
		}
		private void LoadScores (Range _range, LoadScoreCompletion _onCompletion)
		{
			// Cache properties
			m_range					= _range;
			SetLoadScoreFinishedEvent(_onCompletion);

			// Load scores
			loadScores(GetLeaderboardInfoJSONObject().ToJSON());
		}
Пример #48
0
 public override void LoadPlayerCenteredScores(LoadScoreCompletion _onCompletion)
 {
     base.LoadPlayerCenteredScores(_onCompletion);
     GameServicesAndroid.Plugin.Call(GameServicesAndroid.Native.Methods.LOAD_PLAYER_CENTERED_SCORES, GetInstanceID(), Identifier, GetTimeScopeString(), GetUserScopeString(), MaxResults);
 }
Пример #49
0
        public override void LoadMoreScores(eLeaderboardPageDirection _pageDirection, LoadScoreCompletion _onCompletion)
        {
            base.LoadMoreScores(_pageDirection, _onCompletion);

            // Load scores
            EditorGameCenter.Instance.LoadMoreScores(this, _pageDirection);
        }
Пример #50
0
 public override void LoadMoreScores(eLeaderboardPageDirection _pageDirection, LoadScoreCompletion _onCompletion)
 {
     base.LoadMoreScores(_pageDirection, _onCompletion);
     GameServicesAndroid.Plugin.Call(GameServicesAndroid.Native.Methods.LOAD_MORE_SCORES, GetInstanceID(), Identifier, (int)_pageDirection, MaxResults);
 }