public async Task CallAchievementUnlockEventAsync(IAchievement achievement, IDiscordUser user, IDiscordTextChannel channel)
{
DogStatsd.Counter("achievements.gained", 1);
if (achievement as AchievementAchievement != null)
{
return;
}
long id = user.Id.ToDbLong();
using (var context = new MikiContext())
{
int achievementCount = await context.Achievements
.Where(q => q.UserId == id)
.CountAsync();
AchievementPacket p = new AchievementPacket()
{
discordUser = user,
discordChannel = channel,
achievement = achievement,
count = achievementCount
};
await OnAchievementUnlocked?.Invoke(p);
}
}
private void OnRequestAchievementsCompleted(AGSRequestAchievementsResponse response)
{
if (loadAchievementDescriptionsCallbacks.ContainsKey(response.userData))
{
var callback = loadAchievementDescriptionsCallbacks[response.userData];
if (callback != null)
{
var descriptions = new IAchievementDescription[response.achievements.Count];
for (var i = 0; i < response.achievements.Count; i++)
{
descriptions[i] = new AGSSocialAchievement(response.achievements[i]);
}
callback(descriptions);
}
loadAchievementDescriptionsCallbacks.Remove(response.userData);
}
else if (loadAchievementsCallbacks.ContainsKey(response.userData))
{
var callback = loadAchievementsCallbacks[response.userData];
if (callback != null)
{
var achievements = new IAchievement[response.achievements.Count];
for (var i = 0; i < response.achievements.Count; i++)
{
achievements[i] = new AGSSocialAchievement(response.achievements[i]);
}
callback(achievements);
}
loadAchievementsCallbacks.Remove(response.userData);
}
}
public void FindAllAchievements(Assembly assembly)
{
//
List <Type> types = assembly.GetTypes().Where(t => t.IsSubclassOf(typeof(AchievementBase)) && !t.IsAbstract).ToList();
foreach (Type type in types)
{
try
{
IAchievement achievement = Activator.CreateInstance(type) as IAchievement;
if (achievement != null)
{
IAchievement alreadyExists = Achievements.FirstOrDefault(x => x.Id == achievement.Id);
if (alreadyExists != null)
{
Log.Default.WriteLine(LogLevels.Error, "Achievement {0} and {1} share the same id {2}", achievement.Title, alreadyExists.Title, achievement.Id);
}
else
{
_achievements.Add(achievement);
achievement.Achieved += AchievementAchieved;
}
}
else
{
Log.Default.WriteLine(LogLevels.Warning, "Achievement {0} cannot be instantiated and casted to right IAchievement", type.FullName);
}
}
catch (Exception ex)
{
Log.Default.WriteLine(LogLevels.Warning, "Achievement {0} cannot be instantiated. Exception: {1}", type.FullName, ex.ToString());
}
}
}
// This function gets called when the LoadAchievement call completes
void ProcessLoadedAchievements(IAchievement[] achievements)
{
if (achievements.Length == 0)
{ }
else
{ }
}
public async Task CallAchievementUnlockEventAsync(IAchievement achievement, IDiscordUser user, IDiscordTextChannel channel)
{
if (achievement as AchievementAchievement == null)
{
return;
}
long id = user.Id.ToDbLong();
using (var scope = MikiApp.Instance.Services.CreateScope())
{
var context = scope.ServiceProvider
.GetService <MikiDbContext>();
int achievementCount = await context.Achievements
.Where(q => q.UserId == id)
.CountAsync();
AchievementPacket p = new AchievementPacket()
{
discordUser = user,
discordChannel = channel,
achievement = achievement,
count = achievementCount
};
await OnAchievementUnlocked?.Invoke(p);
}
}
private void AwardThirdPartyAchievements(string in_achievements)
{
#if !(DOT_NET)
// only do it for logged in players
if (!UnityEngine.Social.localUser.authenticated)
{
Debug.Log("Couldnt award Unity Social achievement because localUser was not authenticated");
return;
}
IAchievement achievement = UnityEngine.Social.CreateAchievement();
achievement.id = in_achievements;
achievement.percentCompleted = 100.0; //progress as double
achievement.ReportProgress(result =>
{
if (result)
{
Debug.Log("AwardThirdPartyAchievements Success");
}
else
{
Debug.Log("AwardThirdPartyAchievements Failed");
}
});
#endif
}
private StackPanel CreateBadge(IAchievement achievement, EntityManager entityManager)
{
var background = new StackPanel("badge")
{
Width = WaveServices.Platform.ScreenWidth, Height = 150, DrawOrder = 1
};
var headline = new TextBlock()
{
Text = "Achievement completed!",
};
var title = new TextBlock()
{
Text = achievement.Title,
};
var description = new TextBlock()
{
Text = achievement.Description,
};
var dismissButton = new Button()
{
Text = "Dismiss",
};
dismissButton.Click += (sender, args) => entityManager.Remove("badge");
background.Add(headline);
background.Add(title);
background.Add(description);
return(background);
}
private void AchievementCompleted(IAchievement achievement)
{
var entityManager = WaveServices.ScreenContextManager.CurrentContext[0].EntityManager;
var badge = CreateBadge(achievement, entityManager);
entityManager.Add(badge);
}
public void AddAchievement(IAchievement achievement)
{
var completedAchiemevent =
new CompletedAchievement(DateTime.Now, achievement);
CompletedAchievements.Add(completedAchiemevent);
}
public HashSet <IAchievement> GetAchievements(uint appId)
{
var i = new SteamUserStats(_apiKey);
var achievementsTask = i.GetSchemaForGameAsync(appId);
HashSet <IAchievement> achievements = new HashSet <IAchievement>();
var response = achievementsTask.Result.Data;
if (response.AvailableGameStats == null || response.AvailableGameStats.Achievements == null)
{
return(new HashSet <IAchievement>());
}
IReadOnlyCollection <SchemaGameAchievementModel> resultList = response.AvailableGameStats.Achievements;
foreach (SchemaGameAchievementModel a in resultList)
{
IAchievement ach = new Achievement(a.DisplayName, a.Description, a.Icon, a.Name);
achievements.Add(ach);
}
var globalPercentageTask = i.GetGlobalAchievementPercentagesForAppAsync(appId);
foreach (GlobalAchievementPercentageModel globalAchievementPercentageModel in globalPercentageTask.Result.Data)
{
IAchievement achievement = achievements.FirstOrDefault(a => a.InternalShortName == globalAchievementPercentageModel.Name);
if (achievement != null)
{
achievement.GlobalCompletionPercentage = globalAchievementPercentageModel.Percent;
}
}
return(achievements);
}
private void CreateAchievement(IAchievement achievement, int row)
{
var titleText = new TextBlock()
{
Text = String.Format("{0}\r\n({1})", achievement.Title, achievement.Description),
TextAlignment = TextAlignment.Left,
HorizontalAlignment = HorizontalAlignment.Left,
Height = 55
};
titleText.SetGridProperties(row, 0);
var completedText = new TextBlock()
{
Text = achievement.PercentageCompleted >= 100 ? "Completed" : "Not completed",
TextAlignment = TextAlignment.Right,
HorizontalAlignment = HorizontalAlignment.Right,
Width = 200
};
completedText.SetGridProperties(row, 1);
_grid.Add(titleText);
_grid.Add(completedText);
}
private void AwardThirdPartyAchievements(string in_achievements)
{
#if !(DOT_NET)
// only do it for logged in players
UnityEngine.Social.localUser.Authenticate(success =>
{
if (success)
{
IAchievement achievement = UnityEngine.Social.CreateAchievement();
achievement.id = in_achievements;
achievement.percentCompleted = 100.0; //progress as double
achievement.ReportProgress(result =>
{
if (result)
{
Console.Write("AwardThirdPartyAchievements Success");
}
else
{
Console.Write("AwardThirdPartyAchievements Failed");
}
});
}
});
#endif
}
public void Achieve(string id)
{
if (isAchievesLoaded)
{
IAchievement achieve = achievements[id];
if (!achieve.completed)
{
AudioCenter.Instance.PlaySound("Achieve");
Social.ReportProgress(id, 100.0, (success) => {
if (success)
{
isAchievesLoaded = false;
Social.LoadAchievements((achieves) => {
achievements = new Dictionary <string, IAchievement>();
for (int i = 0; i < achieves.Length; i++)
{
achievements.Add(achieves[i].id, achieves[i]);
}
isAchievesLoaded = true;
});
}
});
}
}
}
public virtual void SetUp()
{
_autoMocker = new RhinoAutoMocker <PlayerAchievementRetriever>();
_autoMocker.PartialMockTheClassUnderTest();
_expectedAchievement = new FakeAchievement();
_autoMocker.Get <IAchievementRetriever>().Expect(mock => mock.GetAchievement(_achievementId)).Return(_expectedAchievement);
_expectedPlayer = new Player
{
Name = "some player name",
Id = 51
};
_playerAchievement = new PlayerAchievement
{
AchievementId = _achievementId,
DateCreated = DateTime.UtcNow.AddDays(-15),
LastUpdatedDate = DateTime.UtcNow,
PlayerId = _expectedPlayer.Id
};
var playerAchievementsQueryable = new List <PlayerAchievement>
{
//--achievement with non-matching id
new PlayerAchievement(),
new PlayerAchievement
{
AchievementId = _achievementId
},
_playerAchievement
}.AsQueryable();
_autoMocker.Get <IDataContext>().Expect(mock => mock.GetQueryable <PlayerAchievement>()).Return(playerAchievementsQueryable);
}
// This function gets called when the LoadAchievement call completes
void ProcessLoadedAchievements(IAchievement[] achievements)
{
if (achievements.Length == 0)
Debug.Log ("Error: no achievements found");
else
Debug.Log ("Got " + achievements.Length + " achievements");
}
private void CreateOrUpdateAchievement(Player player, IAchievement achievement, PlayerAchievement currentPlayerAchievement,
AchievementAwarded achievementAwarded)
{
if (currentPlayerAchievement == null)
{
var playerAchievement = new PlayerAchievement
{
DateCreated = DateTime.UtcNow,
LastUpdatedDate = DateTime.UtcNow,
Player = player,
PlayerId = player.Id,
AchievementId = achievement.Id,
AchievementLevel = achievementAwarded.LevelAwarded.Value,
RelatedEntities = achievementAwarded.RelatedEntities
};
DataContext.Save(playerAchievement, new AnonymousApplicationUser());
NotifyPlayer(player, achievement, achievementAwarded.LevelAwarded);
}
else
{
currentPlayerAchievement.RelatedEntities = achievementAwarded.RelatedEntities;
if ((int)achievementAwarded.LevelAwarded.Value > (int)currentPlayerAchievement.AchievementLevel)
{
currentPlayerAchievement.AchievementLevel = achievementAwarded.LevelAwarded.Value;
currentPlayerAchievement.LastUpdatedDate = DateTime.UtcNow;
NotifyPlayer(player, achievement, achievementAwarded.LevelAwarded);
}
}
}
internal AchievementDto(IAchievement achievement)
{
id = achievement.id;
percentCompleted = achievement.percentCompleted;
completed = achievement.completed;
hidden = achievement.hidden;
lastReportedDate = achievement.lastReportedDate;
}
private IAchievement GetMockAchievementWithEarnedState(bool i_earnedState)
{
IAchievement mockAchievement = Substitute.For <IAchievement>();
mockAchievement.IsEarned().Returns(i_earnedState);
return(mockAchievement);
}
public void CantBuyFromBankWithoutPlayer()
{
var board = new Mock<IBoard>();
var achievements = new IAchievement[0];
var bank = new Bank(board.Object, achievements);
Assert.Throws<ArgumentNullException>(() => bank.BuyResource(MaterialType.Brick, MaterialType.Grain, null));
}
public void CantOfferInvalidResource(MaterialType material)
{
var board = new Mock<IBoard>();
var player = new Mock<IPlayer>();
var achievements = new IAchievement[0];
var bank = new Bank(board.Object, achievements);
Assert.Throws<ArgumentException>(() => bank.BuyResource(MaterialType.Grain, material, player.Object));
}
public async Task UnlockAsync(IAchievement achievement, IDiscordUser user, int r = 0)
{
long userid = user.Id.ToDbLong();
if (await UnlockIsValid(achievement, userid, r))
{
await Notification.SendAchievementAsync(achievement, user);
}
}
private void OnAchievementEarned(IAchievement achievement, bool firstTime)
{
lock (_lock)
{
Console.ResetColor();
Console.SetCursorPosition(_client.Board.Width + 2 + BoardStartX, 0);
Console.Write("You have earned [{0}]", achievement.Title);
}
}
public HomeController(ILogger <HomeController> logger,
IThread thread,
IAchievement achievementService,
UserManager <LoginUser> userManager)
{
_threadService = thread;
_achievementService = achievementService;
_userManager = userManager;
}
public IAchievement SetCurrentAchievement(IAchievement target)
{
currenAchievement = target;
currenAchievement.Activate();
RestartTimer();
return(currenAchievement);
}
private void AchievementAchieved(IAchievement achievement, bool firstTime)
{
Achieved?.Invoke(achievement, firstTime);
foreach (IAchievement iter in Achievements.Where(x => x.IsAchievable))
{
iter.OnAchievementEarned(achievement, Achievements);
}
}
public void Select(int achievementId)
{
SelectedItem = Achievements.FirstOrDefault(x => x.Id == achievementId);
//if (achievement != null)
//{
// int index = Achievements.IndexOf(achievement);
// SelectedIndex = index;
//}
}
private void DoAchievementCompleted(IAchievement achievement)
{
var handler = AchievementCompleted;
if (null != handler)
{
handler(achievement);
}
}
public static AchievementViewModel CreateFrom(IAchievement achievement)
{
var src = new StreamImageSource
{
Stream = token => achievement.LoadImage()
};
return(new AchievementViewModel(achievement, src));
}
public static void Add(IAchievement a)
{
if (!enabled)
{
throw new InvalidOperationException("Initialize must be called before using the AchievementHolder.");
}
//Add the achievement to the list
achievements.Add(a.Name, a);
}
private void OnAchievementEarned(IAchievement achievement, bool firstTime)
{
if (Client.IsSpectator)
return;
Achievement = achievement.Title;
_achievementTimer.Stop();
_lastAchievement = DateTime.Now;
AchievementOpacity = 1;
_achievementTimer.Start();
}
private void OnAchievementEarned(IAchievement achievement, bool firstTime)
{
if (achievement != null && firstTime && (Client.IsPlaying || Client.IsSpectator || ClientOptionsViewModel.Instance.DisplayOpponentsFieldEvenWhenNotPlaying))
{
AddEntry(new SelfAchievementEarnedEntry
{
AchievementTitle = achievement.Title
});
}
}
/// <summary>
/// Updates the data displayed by the notification.
/// </summary>
/// <param name="achievement">Achievement to be displayed.</param>
/// <returns></returns>
private void UpdateDisplayedData(IAchievement achievement)
{
AchievementTitle = achievement.Title;
AchievementDescription = achievement.Description;
var source = new StreamImageSource
{
Stream = token => achievement.LoadImage()
};
AchievementImage = source;
}
private void OnAchievementEarned(IAchievement achievement, bool firstTime)
{
Log.Default.WriteLine(LogLevels.Info, "Achievement: {0} {1} {2:dd/MM/yyyy HH:mm:ss}", achievement.Title, firstTime, achievement.LastTimeAchieved);
Settings.Default.Achievements.Save(Client.Achievements.ToList());
Settings.Default.Save();
ExecuteOnUIThread.Invoke(() => Achievements = BuildAchievementList(Client.Achievements.ToList()));
//
RefreshAchievementsStats();
}
void Start()
{
GameCenterPlatform.ShowDefaultAchievementCompletionBanner(true);
IAchievement achievement = Social.CreateAchievement();
achievement.id = "axy01";
Social.localUser.Authenticate(HandleAuthenticated);
Debug.Log(Social.localUser);
}
private void HandleAchievementsLoaded (IAchievement[] achievements)
{
Debug.Log ("*** HandleAchievementsLoaded");
foreach (IAchievement achievement in achievements)
{
Debug.Log ("* achievement = " + achievement.ToString ());
}
}
// This function gets called when the LoadAchievement call completes
void ProcessLoadedAchievements (IAchievement[] achievements) {
if (achievements.Length == 0)
Debug.Log ("Error: no achievements found");
else
Debug.Log ("Got " + achievements.Length + " achievements");
// You can also call into the functions like this
Social.ReportProgress ("Achievement01", 100.0, result => {
if (result)
Debug.Log ("Successfully reported achievement progress");
else
Debug.Log ("Failed to report achievement");
});
}
public static void init(IAchievement[] loadedAchievements) {
achievementDict = new Dictionary<string, List<AchievementObject>>();
allAchievements = new List<AchievementObject>();
// I know that this code for getting current progress of achievement is very dirty. Don't do like this next time :D
Dictionary<string, IAchievement> loadedAchievementDict = new Dictionary<string, IAchievement>();
foreach (IAchievement loadedAch in loadedAchievements) {
loadedAchievementDict.Add(loadedAch.id, loadedAch);
}
List<AchievementObject> objList;
// Beginning of the journey
// objList = new List<AchievementObject>();
// objList.Add(new AchievementObject("CgkIubjEkcMWEAIQBQ", false, true));
// achievements.Add("TutorialDone", objList);
// Dreamwalker series
objList = new List<AchievementObject>();
objList.Add(new AchievementObject("DREAMWALKER_1", 0, 1000, loadedAchievementDict[SocialPlatformManager.spm.achievementInfoMap["DREAMWALKER_1"]].percentCompleted));
objList.Add(new AchievementObject("DREAMWALKER_2", 0, 2500, loadedAchievementDict[SocialPlatformManager.spm.achievementInfoMap["DREAMWALKER_2"]].percentCompleted));
objList.Add(new AchievementObject("DREAMWALKER_3", 0, 5000, loadedAchievementDict[SocialPlatformManager.spm.achievementInfoMap["DREAMWALKER_3"]].percentCompleted));
allAchievements.AddRange(objList);
achievementDict.Add("BestCubes", objList);
// Toy collector series
objList = new List<AchievementObject>();
objList.Add(new AchievementObject("COLLECTOR_1", 0, 5, loadedAchievementDict[SocialPlatformManager.spm.achievementInfoMap["COLLECTOR_1"]].percentCompleted));
objList.Add(new AchievementObject("COLLECTOR_2", 0, 10, loadedAchievementDict[SocialPlatformManager.spm.achievementInfoMap["COLLECTOR_2"]].percentCompleted));
objList.Add(new AchievementObject("COLLECTOR_3", 0, 20, loadedAchievementDict[SocialPlatformManager.spm.achievementInfoMap["COLLECTOR_3"]].percentCompleted));
allAchievements.AddRange(objList);
achievementDict.Add("NumCharactersHave", objList);
// Traveler series
objList = new List<AchievementObject>();
objList.Add(new AchievementObject("TRAVELER_1", 0, 20000, loadedAchievementDict[SocialPlatformManager.spm.achievementInfoMap["TRAVELER_1"]].percentCompleted));
objList.Add(new AchievementObject("TRAVELER_2", 0, 100000, loadedAchievementDict[SocialPlatformManager.spm.achievementInfoMap["TRAVELER_2"]].percentCompleted));
objList.Add(new AchievementObject("TRAVELER_3", 0, 1000000, loadedAchievementDict[SocialPlatformManager.spm.achievementInfoMap["TRAVELER_3"]].percentCompleted));
allAchievements.AddRange(objList);
achievementDict.Add("TotalCubes", objList);
// Update AchievementObjects
DataManager.dm.setInt("BestCubes", DataManager.dm.getInt("BestCubes"));
DataManager.dm.setInt("NumCharactersHave", DataManager.dm.getInt("NumCharactersHave"));
DataManager.dm.setInt("TotalCubes", DataManager.dm.getInt("TotalCubes"));
foreach (AchievementObject obj in allAchievements) {
obj.report(0);
}
SocialPlatformManager.spm.am.reportAllLeaderboard();
}
private void ProcessLoadedAchievements(IAchievement[] achievements)
{
if(achievements.Length > 0)
hasLoadedSocial = true;
}
public void BuyFailsIfPlayerHasNotTheOfferedResources()
{
var board = new Mock<IBoard>();
board.Setup(b => b.GetHarbors(It.IsAny<IPlayer>())).Returns(new IHarbor[] { });
var player = new Mock<IPlayer>();
player.Setup(p => p.HasResources(It.IsAny<MaterialType[]>())).Returns(false);
var achievements = new IAchievement[0];
var bank = new Bank(board.Object, achievements);
Assert.Throws<InvalidOperationException>(() => bank.BuyResource(MaterialType.Grain, MaterialType.Lumber, player.Object));
}
internal iOSAchievement (string _identifier)
{
m_achievementData = Social.CreateAchievement();
Identifier = _identifier;
}
void ProcessLoadedAchievements( IAchievement[] achievements )
{
// Clear this list
// if ( this.achievements != null ) {
// achievements = this.achievements;
// }
if ( achievements.Length <= 0 ) {
Debug.Log("Achievement not found.");
}
else {
if ( ! Property.release )
{
Debug.Log("Got "+achievements.Length+" achievements.");
}
this.achievements = achievements;
}
}
public void onLoadAchievements(IAchievement[] items)
{
}
internal static iOSAchievement[] ConvertAchievementList (IAchievement[] _achievementList)
{
if (_achievementList == null)
return null;
int _count = _achievementList.Length;
iOSAchievement[] _iOSAchievementList = new iOSAchievement[_count];
for (int _iter = 0; _iter < _count; _iter++)
_iOSAchievementList[_iter] = new iOSAchievement(_achievementList[_iter]);
return _iOSAchievementList;
}
public void CantVerifyWinConditionOnNullPlayer()
{
var board = new Mock<IBoard>();
var achievements = new IAchievement[0];
var bank = new Bank(board.Object, achievements);
Assert.Throws<ArgumentNullException>(() => bank.VerifyWinCondition(null));
}
public void BuyDevelopmentCardTest()
{
var board = new Mock<IBoard>();
var player = new Mock<IPlayer>();
var turn = new Mock<ITurn>();
player.Setup(p => p.HasResources(Bank.DEVELOPMENTCARD_COST)).Returns(true);
var achievements = new IAchievement[0];
var bank = new Bank(board.Object, achievements);
bank.BuyDevelopmentCard(player.Object, turn.Object);
player.Verify(p => p.TakeResources(Bank.DEVELOPMENTCARD_COST));
player.Verify(p => p.AddCard(It.IsAny<IDevelopmentCard>()));
}
public void DifferentResourceHarborGetsIgnored()
{
var board = new Mock<IBoard>();
var player = new Mock<IPlayer>();
var achievements = new IAchievement[0];
var bank = new Bank(board.Object, achievements);
var harbor = new Mock<IHarbor>();
harbor.Setup(h => h.Discount).Returns(MaterialType.Wool);
board.Setup(b => b.GetHarbors(player.Object)).Returns(new IHarbor[] { harbor.Object });
MaterialType[] result = bank.GetInvestmentCost(MaterialType.Grain, player.Object);
MaterialType[] expected = { MaterialType.Grain, MaterialType.Grain, MaterialType.Grain, MaterialType.Grain };
Assert.Equal(expected, result);
}
void AchievementInitiate()
{
achievement = Social.CreateAchievement();
}
public void BuyDevelopmentCardFailsIfPlayerHasNoResources()
{
var board = new Mock<IBoard>();
var player = new Mock<IPlayer>();
var turn = new Mock<ITurn>();
player.Setup(p => p.HasResources(Bank.DEVELOPMENTCARD_COST)).Returns(false);
var achievements = new IAchievement[0];
var bank = new Bank(board.Object, achievements);
Assert.Throws<InvalidOperationException>(() => bank.BuyDevelopmentCard(player.Object, turn.Object));
}
private void HandleAchievementsLoaded(IAchievement[] achievements)
{
foreach (IAchievement achievement in achievements) {
}
}
public void BuyDevelopmentCantBeCalledWithoutPlayer(IPlayer player, ITurn turn)
{
var board = new Mock<IBoard>();
var achievements = new IAchievement[0];
var bank = new Bank(board.Object, achievements);
Assert.Throws<ArgumentNullException>(() => bank.BuyDevelopmentCard(player, turn));
}
public void GetInvestmentCostDefaultReturns4()
{
var board = new Mock<IBoard>();
var player = new Mock<IPlayer>();
var achievements = new IAchievement[0];
var bank = new Bank(board.Object, achievements);
MaterialType[] result = bank.GetInvestmentCost(MaterialType.Grain, player.Object);
MaterialType[] expected = { MaterialType.Grain, MaterialType.Grain, MaterialType.Grain, MaterialType.Grain };
Assert.Equal(expected, result);
}
public void GetInvestmentCostUsesCheapestHarbor()
{
var board = new Mock<IBoard>();
var player = new Mock<IPlayer>();
var achievements = new IAchievement[0];
var bank = new Bank(board.Object, achievements);
var unsourcedHarbor = new Mock<IHarbor>();
unsourcedHarbor.Setup(h => h.Discount).Returns(MaterialType.Unsourced);
var resourceHarbor = new Mock<IHarbor>();
resourceHarbor.Setup(h => h.Discount).Returns(MaterialType.Grain);
board.Setup(b => b.GetHarbors(player.Object)).Returns(new IHarbor[] { unsourcedHarbor.Object, resourceHarbor.Object });
MaterialType[] result = bank.GetInvestmentCost(MaterialType.Grain, player.Object);
MaterialType[] expected = { MaterialType.Grain, MaterialType.Grain };
Assert.Equal(expected, result);
}
void OnLoadAC(IAchievement[] achievements)
{
}
internal iOSAchievement (IAchievement _achievementData)
{
m_achievementData = _achievementData;
}
void ProcessLoadedAchievements(IAchievement[] achievements)
{
//Clear the list
if(this.achievements != null)
this.achievements = null;
if (achievements.Length == 0)
Debug.Log ("Error: no achievements found");
else
{
Debug.Log ("Got " + achievements.Length + " achievements");
this.achievements = achievements;
}
}
public void reportAllAchievements(IAchievement[] achievements) {
// Because LoadAchievements() does not work, just report current progress
AchievementConstants.init(achievements);
}
/// <summary>
/// Loads the achievement state for the current user.
/// <param name="callback">The callback to receive the achievements</param>
/// </summary>
public void LoadAchievements(Action<IAchievement[]> callback)
{
if (!IsAuthenticated())
{
GooglePlayGames.OurUtils.Logger.e("LoadAchievements can only be called after authentication.");
callback.Invoke(null);
}
mClient.LoadAchievements(ach =>
{
IAchievement[] data = new IAchievement[ach.Length];
for (int i = 0; i < data.Length; i++)
{
data[i] = new PlayGamesAchievement(ach[i]);
}
callback.Invoke(data);
});
}
public void BuyCardFailsWhenNoMoreCardsLeft()
{
var board = new Mock<IBoard>();
var player = new Mock<IPlayer>();
var turn = new Mock<ITurn>();
player.Setup(p => p.HasResources(Bank.DEVELOPMENTCARD_COST)).Returns(true);
var achievements = new IAchievement[0];
var bank = new Bank(board.Object, achievements);
for (int i = 0; i < 25; i++)
{
bank.BuyDevelopmentCard(player.Object, turn.Object);
}
Assert.Throws<InvalidOperationException>(() => bank.BuyDevelopmentCard(player.Object, turn.Object));
}
public void onLoadAchievements(IAchievement[] items)
{
Debug.Log ("onLoadAchievements");
}
public void OnLoadAC(IAchievement[] achievements)
{
Debug.Log("GPGUI: Loaded Achievements: " + achievements.Length);
}
