private AchievementProgress GetNumberOfConsectiveGoalDayGroups(IEnumerable <GoalStorageModel> goals, int consecutiveDaysTarget)
{
AchievementProgress result = new AchievementProgress();
int consecutiveDays = 0;
foreach (var g in goals)
{
if (g.HasBeenReached)
{
consecutiveDays++;
if (consecutiveDays == consecutiveDaysTarget)
{
AddProgress(ref result, g.Day);
//NOTE: We want to display a full graph in frontend if we completed today
consecutiveDays = (g.Day == DateTime.Today) ? consecutiveDaysTarget : 0;
}
}
else if (g.Day != DateTime.Today)
{
consecutiveDays = 0;
}
}
result.SubProgress = consecutiveDays;
return(result);
}
public async Task IncrementAchievementProgress(LoginUser user, int achievementId)
{
AchievementProgress getAch = GetUsersAchievementProgress(user, achievementId);
getAch.UsersProgress += 1;
await _context.SaveChangesAsync();
}
public async Task GiveTenAchievement(LoginUser user)
{
AchievementProgress ach = GetUsersAchievementProgress(user, 3);
achievementDetails(ach, user, 10, true, 1);
await _context.SaveChangesAsync();
}
private static void AddProgress(ref AchievementProgress progress, DateTime progressAt)
{
if (progress.Progress == null)
{
progress.Progress = new List <DateTime>();
}
progress.Progress.Add(progressAt);
}
public async Task GiveFirstLoginAchievement(LoginUser user)
{
//give the user the achievement
AchievementProgress ach = GetUsersAchievementProgress(user, 1);
achievementDetails(ach, user, 1, true, 1);
await _context.SaveChangesAsync();
}
public int FollowAchievementProgress(LoginUser user)
{
//need to fix if there is no achievemtns
AchievementProgress ach = GetUsersAchievementProgress(user, 3);
if (ach == null)
{
return(0);
}
return(ach.UsersProgress);
}
private void achievementDetails(AchievementProgress ach, LoginUser user, int userProgress, bool completed, int ratting)
{
//give the user the achievement
//users progress
ach.UsersProgress = userProgress;
//when the user completed it
ach.CompletedTime = DateTime.Now;
//set it to true because its complete
ach.Completed = completed;
//gives the user +1 to their ratting for the Achievement
user.Ratting += ratting;
}
private AchievementProgress[] CalculateAchievements(List <SavedPoi> poiSaved)
{
var achievements = _contentService.GetAllAchievements();
var progress = new List <AchievementProgress>();
foreach (var a in achievements)
{
var p = new AchievementProgress(a);
var done = poiSaved.Count(pSaved => pSaved.Visited && pSaved.CategoryId == a.CategoryId);
p.Done = done;
progress.Add(p);
}
return(progress.ToArray());
}
public bool CheckProgression(LoginUser user, int achievementId)
{
if (GetUsersAchievement(user).Count() == 0)
{
return(false);
}
AchievementProgress getAch = GetUsersAchievementProgress(user, achievementId);
bool progress = getAch.Completed;
if (progress)
{
return(true);
}
else
{
return(false);
}
}
private async Task AddAchievementProgress(TieredAchievementModel achievement, AchievementProgress progress)
{
var storedProgress = GetProgressCurrentTier(achievement);
if (progress.Progress != null)
{
foreach (var p in progress.Progress)
{
storedProgress.Progress++;
storedProgress.TimeProgressAchieved = p;
if (storedProgress.Progress >= achievement.Type.GetGoal(achievement.CurrentTier))
{
storedProgress.DateTierAchieved = p;
await storageService.UpdateTieredAchievementProgress(storedProgress);
OnTierChanged?.Invoke(achievement.Type, achievement.CurrentTier);
achievement.CurrentTier++;
if (achievement.CurrentTier == Tier.Complete)
{
break;
}
storedProgress = GetProgressCurrentTier(achievement);
storedProgress.TimeProgressAchieved = p;
await storageService.UpdateTieredAchievementProgress(storedProgress);
}
}
}
if (storedProgress.SubProgress != progress.SubProgress)
{
storedProgress.SubProgress = progress.SubProgress;
OnTierProgress?.Invoke(achievement.Type);
}
}
public async Task CheckTieredAchievementsProgress(TodaysWalkingModel todaysWalking)
{
if (isUpdating || todaysWalking == null)
{
return;
}
isUpdating = true;
if (updateTask == null || updateTask.IsCompleted)
{
updateTask = Task.Run(async() =>
{
var walkingHistory = await storageService.GetWalkingDays();
var goalHistory = await storageService.GetAllGoalResults();
foreach (var a in tieredAchievements)
{
Tier tier = a.CurrentTier;
if (tier == Tier.Complete)
{
continue;
}
var storedProgress = GetProgressCurrentTier(a);
var relevantWalking = walkingHistory.Where(d => d.Day > storedProgress.TimeProgressAchieved);
var relevantGoals = goalHistory.Where(g => g.Day > storedProgress.TimeProgressAchieved);
switch ((TieredAchievement)a.Id)
{
case TieredAchievement.ReachedGoal:
{
var goals = relevantGoals.Where(g => g.HasBeenReached);
if (goals.Any())
{
AchievementProgress p = new AchievementProgress
{
Progress = goals.Select(g => g.Day).ToList(),
};
await AddAchievementProgress(a, p);
}
}
break;
case TieredAchievement.ThirtyMinutes:
{
var walking = relevantWalking.Where(d => d.MinutesBriskWalking + d.MinutesRegularWalking >= 30);
var subProgress = (int)(todaysWalking.minutesBriskWalkToday +
todaysWalking.minutesRegularWalkToday +
todaysWalking.minutesUnknownWalkToday);
AchievementProgress p = new AchievementProgress
{
Progress = walking.Select(w => w.Day).ToList(),
SubProgress = subProgress,
};
await AddAchievementProgress(a, p);
}
break;
case TieredAchievement.ReachedGoalFiveDaysInARow:
{
var progress = GetNumberOfConsectiveGoalDayGroups(relevantGoals, 5);
await AddAchievementProgress(a, progress);
}
break;
}
await storageService.UpdateTieredAchievement(a);
}
});
await updateTask;
}
isUpdating = false;
}
public async Task AssignAchievementsToUser(LoginUser user)
{
var uAch = GetUsersAchievement(user).ToList();
var uuAch = new List <Achievement>();
var aAch = GetAllAchievements().ToList();
var toDB = new List <AchievementProgress>();
if (uAch.Count() == aAch.Count())
{
return;
}
//when there are 0 and you need to add one
if (uAch.Count() == 0)
{
if (aAch.Count() == 1)
{
foreach (var toAdd in aAch)
{
var newAchPro = new AchievementProgress
{
Achievement = toAdd,
Completed = false,
MaxProgress = toAdd.ProgressLimit,
UserId = user.Id,
UsersProgress = 0
};
toDB.Add(newAchPro);
}
var first = toDB.FirstOrDefault();
_context.AchievementProgress.Add(first);
await _context.SaveChangesAsync();
return;
}
else
{
foreach (var toAdd in aAch)
{
var newAchPro = new AchievementProgress
{
Achievement = toAdd,
Completed = false,
MaxProgress = toAdd.ProgressLimit,
UserId = user.Id,
UsersProgress = 0
};
toDB.Add(newAchPro);
}
await _context.AchievementProgress.AddRangeAsync(toDB);
await _context.SaveChangesAsync();
return;
}
}
/*
* gets the difference in lists; the total amount of lists and the users achievement
* converts progress list to a achv list
*/
foreach (var usersAch in uAch)
{
uuAch.Add(usersAch.Achievement);
}
//gets the two lists and gets the difference between the two
var change = aAch.Except(uuAch).ToList();
if (change.Count() > 1)
{
foreach (var toAdd in change)
{
var newAchPro = new AchievementProgress
{
Achievement = toAdd,
Completed = false,
MaxProgress = toAdd.ProgressLimit,
UserId = user.Id,
UsersProgress = 0
};
toDB.Add(newAchPro);
}
await _context.AchievementProgress.AddRangeAsync(toDB);
await _context.SaveChangesAsync();
return;
}
else
{
foreach (var toAdd in change)
{
var newAchPro = new AchievementProgress
{
Achievement = toAdd,
Completed = false,
MaxProgress = toAdd.ProgressLimit,
UserId = user.Id,
UsersProgress = 0
};
toDB.Add(newAchPro);
}
_context.AchievementProgress.Add(toDB.FirstOrDefault());
await _context.SaveChangesAsync();
return;
}
}
public Achievement GetAchievement(string id) {
Achievement result;
if(mAchievements.TryGetValue(id, out result))
return result;
AchievementDefinition def;
if(mAchievementDefinitions.TryGetValue(id, out def)) {
AchievementProgress progress;
if(!mAchievementProgressions.TryGetValue(id, out progress)) {
progress = new AchievementProgress();
progress.Id = def.Id;
mAchievementProgressions.Add(id, progress);
}
result = new Achievement(this, def, progress);
if(result != null)
mAchievements.Add(id, result);
}
return result;
}
public void OnAchieved(Achievement achievement, AchievementProgress progress) {
mAchievedList.AddLast(achievement);
mSaveRequired = true;
Debug.Log(string.Format("Achieved: {0}", achievement.Name));
}
public void OnProgressed(Achievement achievement, AchievementProgress progress, AchievementDefinition.Value value) {
mSaveRequired = true;
Debug.Log(string.Format("Progressed: {0}", achievement.Name));
}
public static String activated()
{
Int64 powerupHash = Int64.Parse(Access.sHttp.request.Path.Split('/')[4]);
PowerupActivated powerupActivated = new PowerupActivated();
powerupActivated.id = powerupHash;
powerupActivated.targetPersonaId = Int32.Parse(Access.sHttp.request.Params.Get("targetId"));
powerupActivated.personaId = Access.CurrentSession.ActivePersona.Id;
PowerupActivatedResponse powerupActivatedResponse = new PowerupActivatedResponse();
powerupActivatedResponse.powerupActivated = powerupActivated;
Message message = new Message();
message.setBody(powerupActivatedResponse);
#pragma warning disable CS4014
object threadSafeDummy = new object();
lock (threadSafeDummy)
{
InventoryItemEntity entity = PersonaManagement.persona.inventory.FirstOrDefault(ii => ii.hash == (Int32)powerupHash);
if (entity != null)
{
entity = InventoryItemManagement.getInventoryItemEntity(entity.id);
entity.remainingUseCount -= 1;
entity.setInventoryItemEntity();
}
// Send powerup activation data to game
Access.sXmpp.write(message.SerializeObject(true));
}
#if DEBUG
lock (threadSafeDummy)
{
if ((Int32)powerupHash == Engine.getOverflowHash("nosshot"))
{
message = new Message();
// Debug, only for showing achievement display
// Will cause the game to crash if achievements/loadall was empty.
AchievementAwarded achievementAwarded = new AchievementAwarded();
var acDef = AchievementDefinitions.achievements["ACH_USE_NOS"];
achievementAwarded.achievementDefinitionId = acDef.achievementDefinition.achievementDefinitionId;
achievementAwarded.achievementRankId = acDef.achievementDefinition.achievementRanks[0].achievementRankId;
achievementAwarded.description = acDef.badgeDefinition.description;
achievementAwarded.icon = acDef.badgeDefinition.icon;
achievementAwarded.isRare = acDef.achievementDefinition.achievementRanks[0].isRare;
achievementAwarded.name = acDef.badgeDefinition.name;
achievementAwarded.points = acDef.achievementDefinition.achievementRanks[0].points;
achievementAwarded.rarity = acDef.achievementDefinition.achievementRanks[0].rarity;
AchievementProgress achievementProgress = new AchievementProgress();
achievementProgress.achievementDefinitionId = acDef.achievementDefinition.achievementDefinitionId;
achievementProgress.currentValue = 1;
AchievementsAwarded achievementsAwarded = new AchievementsAwarded();
achievementsAwarded.achievements.Add(achievementAwarded);
achievementsAwarded.score = Access.CurrentSession.ActivePersona.score;
message.setBody(achievementsAwarded);
Access.sXmpp.write(message.SerializeObject(true));
}
}
#endif
#pragma warning restore CS4014
return("");
}
