public void ProcessRequest(HttpContext context)
{
string achievementid = context.Request.Form["achievementid"];
string achname = context.Request.Form["achievementname"];
string achdesc = context.Request.Form["achievementdescription"];
AchievementDefinition ach = new AchievementDefinition();
using (DBClassesDataContext dc = new DBClassesDataContext())
{
try
{
if (String.IsNullOrEmpty(achievementid))
{
dc.AchievementDefinitions.InsertOnSubmit(ach);
ach.AchievementID = Guid.NewGuid();
}
else
{
ach = (from u in dc.AchievementDefinitions
where u.AchievementID == Guid.Parse(achievementid)
select u).SingleOrDefault();
}
ach.AchievementName = achname;
ach.AchievementDesc = achdesc;
dc.SubmitChanges();
}
catch (Exception e)
{
}
}
}
/// <summary>
/// Fill the achievement item with new data.
/// </summary>
/// <param name="achievement">The achievement details.</param>
public void FillData(AchievementDefinition achievement)
{
// TODO: You may want to replace the default achievement icons by your own ones, according to achievements names
// Update fields
nameText.text = achievement.Name;
// If the achievement is completed, display it
if (achievement.Progress == 1f)
{
achievementProgressBarLine.SetActive(false);
progressText.text = completedText;
achievementItemBackground.color = completedBackgroundColor;
}
// Else, display a progress bar if the achievement progression is not of one-shot type
else
{
if (achievement.Config["maxValue"].AsFloat() == 1f)
{
achievementProgressBarLine.SetActive(false);
progressText.text = uncompletedText;
}
else
{
achievementProgressBarLine.SetActive(true);
progressText.text = GetAchievementProgress(achievement);
progressBarCurrent.flexibleWidth = achievement.Progress;
progressBarMax.flexibleWidth = 1f - achievement.Progress;
}
}
}
public IActionResult UpdateComplete(long id, [FromBody] AchievementDefinition requestAchievementDefinition)
{
if (requestAchievementDefinition == null || !requestAchievementDefinition.Id.Equals(id))
{
return(BadRequest());
}
if (!requestAchievementDefinition.IsComplete())
{
return(BadRequest());
}
AchievementDefinition achievementDefinition = this._context.AchievementDefinitions.FirstOrDefault <AchievementDefinition>(aD => aD.Id.Equals(id));
if (achievementDefinition == null)
{
return(NotFound());
}
achievementDefinition.Update(requestAchievementDefinition);
this._context.Update(achievementDefinition);
this._context.SaveChanges();
return(new NoContentResult());
}
public void Update(AchievementDefinition achievementDefinition)
{
if (achievementDefinition.Name != null)
{
this.Name = achievementDefinition.Name;
}
}
protected void Page_Load(object sender, EventArgs e)
{
mUser = (AppUser)Session[Constants.SESS_KEY_USER];
if (mUser == null)
{
getUserFromCookie();
if (mUser == null)
{
Response.Redirect("login.aspx");
Response.Close();
return;
}
}
RewardID = Request.Params["RewardID"];
achievedWhen = PilotClass.WhenAchieved(Guid.Parse(RewardID), mUser.UserEmail);
rd = RewardDefinition.getRewardDefinition(Guid.Parse(RewardID));
IEnumerable <RewardPrereq> prereqs = RewardPrereq.getPrereqs(Guid.Parse(RewardID));
requirements = new List <AchievementDefinition>();
if (prereqs != null && prereqs.Count <RewardPrereq>() >= 0)
{
foreach (RewardPrereq pcp in prereqs)
{
AchievementDefinition ad = AchievementDefinition.getAchievementDefinition(pcp.RequiredAchievement);
requirements.Add(ad);
}
}
// now we have the list of requirements too.
}
public void ProcessRequest(HttpContext context)
{
string sid = context.Request["achievementid"];
Guid achID = Guid.Parse(sid);
AchievementDefinition.delete(achID);
}
public void ProcessRequest(HttpContext context)
{
Dictionary <String, object> res = new Dictionary <string, object>();
List <Object> finalList = new List <object>();
IEnumerable <AchievementDefinition> achs = AchievementDefinition.getAll();
foreach (AchievementDefinition r in achs)
{
int nAchs = 0;
int nTasks = AchievementPrereq.getPrereqTypes(AchievementPrereq.getPrereqsForAchievement(r.AchievementID), out nAchs);
Dictionary <string, string> obj = new Dictionary <string, string>();
obj.Add("Achievement", r.AchievementName);
obj.Add("Tasks", nTasks.ToString());
obj.Add("Prerequisites", nAchs.ToString());
obj.Add("actions", r.AchievementID.ToString());
obj.Add("AchievementID", r.AchievementID.ToString());
obj.Add("AchievementDesc", r.AchievementDesc);
finalList.Add(obj);
}
res.Add("data", finalList);
string json = JsonConvert.SerializeObject(res);
context.Response.Write(json);
}
/// <summary>
/// Format an achievement progress text.
/// </summary>
/// <param name="achievement">The achievement details.</param>
private string GetAchievementProgress(AchievementDefinition achievement)
{
float currentProgress = achievement.Progress * achievement.Config["maxValue"].AsFloat();
int currentProgressPercent = Mathf.FloorToInt(achievement.Progress * 100f);
return(string.Format(progressFormat, achievement.Config["unit"].AsString(), currentProgress.ToString(floatStringFormat), achievement.Config["maxValue"].AsString(floatStringFormat), currentProgressPercent.ToString()));
}
void Instance_onComplete(AchievementDefinition obj)
{
completedAchievementQueue.Enqueue(obj);
if (!showingAchievement)
{
StartCoroutine(ShowAchievementBox());
}
}
public IActionResult GetById(long id)
{
AchievementDefinition achievementDefinition = this._context.AchievementDefinitions.FirstOrDefault <AchievementDefinition>(aD => aD.Id.Equals(id));
if (achievementDefinition == null)
{
return(NotFound());
}
return(new ObjectResult(achievementDefinition));
}
public IActionResult Create([FromBody] AchievementDefinition achievementDefinition)
{
if (achievementDefinition == null)
{
return(BadRequest());
}
this._context.AchievementDefinitions.Add(achievementDefinition);
this._context.SaveChanges();
return(CreatedAtRoute("[controller]GetById", new { id = achievementDefinition.Id }, achievementDefinition));
}
/// <summary>
/// Build an "achievement unlocked" event type then add it to the pending list to display. (events are displayed one by one)
/// </summary>
/// <param name="eventMessage">Message of the event. (describes an unlocked achievement)</param>
/// <param name="achievement">The unlocked achievement under the AchievementDefinition format.</param>
public void BuildAndAddEventItem_AchievementUnlocked(string eventMessage, AchievementDefinition achievement)
{
// Create an event achievement item GameObject
GameObject achievementItemPrefabInstance = Instantiate <GameObject>(achievementItemPrefab);
// Fill the newly created GameObject with event friend data
AchievementItemHandler achievementItemHandler = achievementItemPrefabInstance.GetComponent <AchievementItemHandler>();
achievementItemHandler.FillData(achievement);
// Add an event item with the newly created GameObject linked to it
AddEventItem(eventMessage, achievementItemPrefabInstance);
}
public IActionResult Delete(long id)
{
AchievementDefinition achievementDefinition = this._context.AchievementDefinitions.FirstOrDefault <AchievementDefinition>(aD => aD.Id.Equals(id));
if (achievementDefinition == null)
{
return(NotFound());
}
this._context.AchievementDefinitions.Remove(achievementDefinition);
this._context.SaveChanges();
return(new NoContentResult());
}
protected void Page_Load(object sender, EventArgs e)
{
mUser = (AppUser)Session[Constants.SESS_KEY_USER];
if (mUser == null)
{
getUserFromCookie();
if (mUser == null)
{
Response.Redirect("login.aspx");
Response.Close();
return;
}
}
items = AchievementDefinition.getAll();
}
//Called by Logins functions (LoginAnonymously, LoginAnonymouslyWithPlayerPref,LoginWithMailOrConvert)
public void SetUpAchievements(TMPro.TMP_Text achievementPanel)
{
achievementPanel.text = "";
LoggedGamer.Achievements.List().Done(achievements => {
foreach (var pair in achievements)
{
string achName = pair.Key;
AchievementDefinition ach = pair.Value;
if (pair.Value.Progress >= 1)
{
achievementPanel.text += pair.Key + '\n';
}
}
});
}
IEnumerator ShowAchievementBox()
{
showingAchievement = true;
while (showingAchievement)
{
completedAchievement = completedAchievementQueue.Dequeue();
// show box
yield return(StartCoroutine(AnimateBox()));
if (completedAchievementQueue.Count == 0)
{
showingAchievement = false;
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
mUser = (AppUser)Session[Constants.SESS_KEY_USER];
if (mUser == null)
{
getUserFromCookie();
if (mUser == null)
{
Response.Redirect("login.aspx");
Response.Close();
return;
}
}
AchievementID = Request.Params["AchievementID"];
achievedWhen = PilotAchievement.WhenAchieved(Guid.Parse(AchievementID), mUser.UserEmail);
rd = AchievementDefinition.getAchievementDefinition(Guid.Parse(AchievementID));
IEnumerable <AchievementPrereq> prereqs = AchievementPrereq.getPrereqsForAchievement(Guid.Parse(AchievementID));
requirements = new List <AchievementDefinition>();
taskrequirements = new List <TaskDefinition>();
if (prereqs != null && prereqs.Count <AchievementPrereq>() >= 0)
{
foreach (AchievementPrereq pcp in prereqs)
{
if (pcp.RequiredAchievementID != null)
{
AchievementDefinition ad = AchievementDefinition.getAchievementDefinition((Guid)pcp.RequiredAchievementID);
if (ad != null)
{
requirements.Add(ad);
}
}
else if (pcp.TaskID != null)
{
TaskDefinition ad = TaskDefinition.getTaskDefinition((Guid)pcp.TaskID);
if (ad != null)
{
taskrequirements.Add(ad);
}
}
}
}
}
void Instance_onComplete(AchievementDefinition def)
{
// save the achievement as completed
PlayerPrefs.SetInt(def.name, 1);
PlayerPrefs.Save();
}
public AchievementDefinitionInfo(AchievementDefinition definition)
{
this.definition = definition;
}
void DisplayDefinitions()
{
EditorStyles.textField.wordWrap = true;
// split window in 2
GUILayout.BeginHorizontal();
GUILayout.BeginVertical(GUILayout.MaxWidth(leftPanelWidth));
GUILayout.Space(5);
// show all items in a listbox
definitionScroll = EditorGUILayout.BeginScrollView(definitionScroll, (GUIStyle)"box");
foreach (Category category in categories.Values)
{
EditorGUILayout.BeginHorizontal();
Rect foldoutRect = GUILayoutUtility.GetRect(new GUIContent(category.category.name), EditorStyles.foldout);
Rect buttonRect = new Rect(foldoutRect.xMin + 15, foldoutRect.yMin, foldoutRect.width - 15, foldoutRect.height);
foldoutRect.width = 15;
category.foldout = EditorGUI.Foldout(foldoutRect, category.foldout, category.category.name);
GUI.depth--;
if (GUI.Button(buttonRect, "", (GUIStyle)"label"))
{
selectedCategory = category;
selectedDefinition = null;
GUI.FocusControl("");
}
GUI.depth++;
EditorGUILayout.EndHorizontal();
if (category.foldout)
{
foreach (AchievementDefinitionInfo definitionInfo in category.achievements)
{
// show selectable name
if (definitionInfo != selectedDefinition)
{
if (GUILayout.Button(definitionInfo.definition.name, (GUIStyle)"label"))
{
selectedDefinition = definitionInfo;
EditorGUIUtility.keyboardControl = 0;
}
}
else
{
GUILayout.Label(definitionInfo.definition.name, (GUIStyle)"boldLabel");
}
}
}
}
EditorGUILayout.EndScrollView();
// add - remove buttons
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("+"))
{
// add new definition
AchievementDefinition newDef = new AchievementDefinition();
newDef.name = "NewAchievement";
achievementDefinitions.definitions.Add(newDef);
AchievementDefinitionInfo info = new AchievementDefinitionInfo(newDef);
definitions.Add(info);
categories[0].achievements.Add(info);
EditorUtility.SetDirty(achievementDefinitions);
selectedDefinition = info;
}
if (GUILayout.Button("-"))
{
// remove selected definition
achievementDefinitions.definitions.Remove(selectedDefinition.definition);
EditorUtility.SetDirty(achievementDefinitions);
definitions.Remove(selectedDefinition);
selectedDefinition = null;
}
EditorGUILayout.EndHorizontal();
if (GUILayout.Button("Add Category"))
{
// add category
AchievementCategory cat = new AchievementCategory();
cat.name = "NewCategory";
cat.id = achievementDefinitions.maxCatId++;
achievementDefinitions.categories.Add(cat);
EditorUtility.SetDirty(achievementDefinitions);
Category category = new Category();
category.category = cat;
categories.Add(category.category.id, category);
BuildCategoryPopup();
selectedCategory = category;
selectedDefinition = null;
}
GUILayout.Space(5);
GUILayout.EndVertical();
// add splitter
leftPanelWidth = Splitter(leftPanelWidth);
GUILayout.BeginVertical();
if (selectedDefinition != null)
{
// show definition info
selectedDefinition.definition.name = EditorGUILayout.TextField("Name", selectedDefinition.definition.name);
selectedDefinition.definition.title = EditorGUILayout.TextField("Title", selectedDefinition.definition.title);
EditorGUI.BeginChangeCheck();
Category oldCat = categories[selectedDefinition.definition.categoryId];
selectedDefinition.definition.categoryId = EditorGUILayout.Popup(getPopupIndexFromCategory(categories[selectedDefinition.definition.categoryId]), categoryPopup.ToArray());
if (EditorGUI.EndChangeCheck())
{
// show in correct category
oldCat.achievements.Remove(selectedDefinition);
categories[selectedDefinition.definition.categoryId].achievements.Add(selectedDefinition);
}
EditorGUILayout.LabelField("Description");
selectedDefinition.definition.description = EditorGUILayout.TextArea(selectedDefinition.definition.description, GUILayout.Height(EditorStyles.textField.lineHeight * 3));
EditorGUILayout.LabelField("Incomplete Description");
selectedDefinition.definition.incompleteDescription = EditorGUILayout.TextArea(selectedDefinition.definition.incompleteDescription, GUILayout.Height(EditorStyles.textField.lineHeight * 3));
selectedDefinition.definition.hidden = EditorGUILayout.Toggle("Hidden", selectedDefinition.definition.hidden);
selectedDefinition.definition.type = (AchievementDefinition.Type)EditorGUILayout.EnumPopup("Type", selectedDefinition.definition.type);
{
// show conditions depending on type
switch (selectedDefinition.definition.type)
{
case AchievementDefinition.Type.Bool:
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(new GUIContent("ConditionValue", "If checked, the variable needs to be true for the achievement to complete"));
// true false checkbox
selectedDefinition.definition.conditionBoolValue = EditorGUILayout.Toggle(selectedDefinition.definition.conditionBoolValue);
EditorGUILayout.EndHorizontal();
break;
case AchievementDefinition.Type.Float:
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(new GUIContent("ConditionValue", "The variable needs to be higher then the value given for the achievement to complete"));
selectedDefinition.definition.conditionFloatValue = EditorGUILayout.FloatField(selectedDefinition.definition.conditionFloatValue);
EditorGUILayout.EndHorizontal();
selectedDefinition.definition.progressChangeSize = EditorGUILayout.FloatField(new GUIContent("Progress Change", "Will report progress when variable is divisable by the given value"), selectedDefinition.definition.progressChangeSize);
break;
case AchievementDefinition.Type.Int:
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(new GUIContent("ConditionValue", "The variable needs to be higher then the value given for the achievement to complete"));
selectedDefinition.definition.conditionIntValue = EditorGUILayout.IntField(selectedDefinition.definition.conditionIntValue);
EditorGUILayout.EndHorizontal();
selectedDefinition.definition.progressChangeSize = EditorGUILayout.FloatField(new GUIContent("Progress Change", "Will report progress when variable is divisable by the given value"), selectedDefinition.definition.progressChangeSize);
break;
}
}
}
else if (selectedCategory != null)
{
EditorGUI.BeginChangeCheck();
selectedCategory.category.name = EditorGUILayout.TextField("Category Name", selectedCategory.category.name);
if (EditorGUI.EndChangeCheck())
{
BuildCategoryPopup();
}
if (selectedCategory.category.id == 0)
{
GUI.enabled = false;
}
if (GUILayout.Button("Remove"))
{
// remove category
foreach (var achievement in selectedCategory.achievements)
{
achievement.definition.categoryId = 0;
categories[0].achievements.Add(achievement);
}
categories.Remove(selectedCategory.category.id);
selectedCategory = null;
EditorUtility.SetDirty(achievementDefinitions);
}
if (selectedCategory == null || selectedCategory.category.id == 0)
{
GUI.enabled = true;
}
}
GUILayout.EndVertical();
GUILayout.EndHorizontal();
if (GUI.changed)
{
EditorUtility.SetDirty(achievementDefinitions);
}
// HACK to unfocus controls
GUI.SetNextControlName("");
}
void Instance_onFloatProgress(AchievementDefinition arg1, float arg2, float arg3)
{
Debug.Log("Made progress with the achievement " + arg1.title + ": " + arg3 + "/" + arg1.conditionFloatValue);
}
public void OnProgressed(Achievement achievement, AchievementProgress progress, AchievementDefinition.Value value) {
mSaveRequired = true;
Debug.Log(string.Format("Progressed: {0}", achievement.Name));
}
//public void registerAchievementVariable<T>(AchievementVariable<T> variable, string identifier) where T : IComparable
//{
// if (!variables.ContainsKey(identifier))
// variables[identifier] = new List<object>();
// variables[identifier].Add(variable);
// Debug.Log("registered achievement variable with identifier: " + identifier);
//}
/// <summary>
/// Automaticly called by an AchievementVariable to notify that the variable has changed. Will fire the progress and completed events if necesary.
/// </summary>
/// <typeparam name="T">The variable type</typeparam>
/// <param name="variable">The AchievementVariable</param>
/// <exception cref="System.ArgumentException">Thrown when there is no matching achievement for the given identifier</exception>
public void VariableChanged <T>(AchievementVariable <T> variable) where T : IComparable
{
// check definitions
if (definitions == null)
{
Init();
}
if (!achievementDefinitions.ContainsKey(variable.identifier))
{
throw new ArgumentException("The identifier " + variable.identifier + " has no matching achievement");
}
// get the associated achievement definition
AchievementDefinition def = achievementDefinitions[variable.identifier];
if (!achievementStates[variable.identifier].completed)
{
//Debug.Log("Checking Achievement " + def.title);
bool completed = false;
switch (def.type)
{
case AchievementDefinition.Type.Bool:
if (variable.Value.Equals(def.conditionBoolValue))
{
completed = true;
}
break;
case AchievementDefinition.Type.Float:
{
AchievementVariable <float> tvar = (AchievementVariable <float>)(object) variable;
int pValue = Mathf.FloorToInt(tvar / def.progressChangeSize);
if (achievementStates[tvar.identifier].progressValue < pValue)
{
onFloatProgress(def, tvar, pValue * def.progressChangeSize);
}
achievementStates[tvar.identifier].progressValue = pValue; // always set it
if (variable.Value.CompareTo(def.conditionFloatValue) >= 0)
{
completed = true;
}
}
break;
case AchievementDefinition.Type.Int:
{
AchievementVariable <int> tvar = (AchievementVariable <int>)(object) variable;
int pValue = Mathf.FloorToInt(tvar / def.progressChangeSize);
if (achievementStates[tvar.identifier].progressValue < pValue)
{
onIntProgress(def, tvar, (int)(pValue * def.progressChangeSize));
}
achievementStates[tvar.identifier].progressValue = pValue; // always set it
if (variable.Value.CompareTo(def.conditionIntValue) >= 0)
{
completed = true;
}
}
break;
}
if (completed)
{
//Debug.Log("Completed achievement " + def.title);
if (onComplete != null)
{
onComplete(def);
}
achievementStates[variable.identifier].completed = true;
achievementStates[variable.identifier].hidden = false;
}
}
}
