// ------------- Behaviour -------------
private void Awake()
{
dicPoolers = new EnumDictionary <PoolerKind, IPooler>();
foreach (Poolers pooler in listPoolers)
{
if (!dicPoolers.ContainsKey(pooler.kind))
{
var iPooler = pooler.objPooler.GetComponent(typeof(IPooler)) as IPooler;
if (iPooler != null)
{
dicPoolers.Add(pooler.kind, iPooler);
}
else
{
#if UNITY_EDITOR
Debug.LogWarning(string.Format($"Can't Find IPooledObject in {pooler.objPooler.name}"));
#endif
}
}
else
{
#if UNITY_EDITOR
Debug.LogWarning(string.Format($"{pooler.kind.ToString()} is Exist"));
#endif
}
}
}
// ------------- Property -------------
// ------------- Behaviour -------------
private void Awake()
{
stackUI = new Stack <UIBase>();
dicUI = new EnumDictionary <UI_Kind, GameObject>();
optionValues = Enum.GetValues(typeof(UI_Option));
OpenWindow(UI_Kind.UIWindow_Home, true);
}
public JsonResult GetHelm()
{
try
{
using (var data = new Entities())
{
var classes = data.Classes.Where(x => x.IsDeleted == false).ToList();
var mappedClasses = data.ClassMaps.Where(
x => x.IsDeleted == false && x.CredentialId == UserInformation.UserInformationCredential.Id)
.ToList()
.Select(
x =>
new
{
x,
ClassName =
(classes.FirstOrDefault(y => y.Id == x.ClassId)?.ClassName ?? "No Class Name")
}).ToList();
var mappedSubject = data.SubjectMaps
.Where(
x => x.IsDeleted == false && x.CredentialId == UserInformation.UserInformationCredential.Id)
.ToList()
.Select(x =>
new
{
x,
SubjectName =
(EnumDictionary.GetList <Subjects>()
.FirstOrDefault(y => y.ItemId == x.SubjectId)?
.ItemName ?? "No Subject Name")
}).ToList();
return(new JsonResult()
{
Data =
new
{
Status = true,
Message = $"All Done",
Data = new { Subjects = mappedSubject, Classes = mappedClasses }
},
JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
}
catch (Exception ex)
{
ActivityLogger.Log(ex);
return(new JsonResult()
{
Data = new { Status = false, Message = ex.Message, Data = string.Empty },
JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
}
private void FrmCentralTagStudent_Shown(object sender, EventArgs e)
{
SetReader(DeviceManager.DeviceSpec.Nfc);
SetCombo(EnumDictionary.GetList <AttendanceReason>(), cmbAttendanceReason);
SetCombo(DatabaseManager.SchoolCourse.Select(x => new EnumList()
{
ItemId = x.Id,
ItemName = x.CourseCode
}).ToList(), cmbCourse);
}
public ITextureAtlas <TEnumKey> Build()
{
EnumDictionary.ThrowIfMissingEnumKey(this.swatches);
var swatches = EnumDictionary.Create <TEnumKey, ITextureSwatch>();
foreach (var pair in this.swatches)
{
swatches[pair.Key] = pair.Value;
}
return(new TextureAtlas <TEnumKey>(swatches));
}
private void CreateCamera()
{
dicCameraObjs = new EnumDictionary <CameraKind, GameObject>();
foreach (var cam in dicCameras)
{
var c = Instantiate <GameObject>(cam.Value.cameraObject, transform);
c.SetActive(false);
if (!dicCameraObjs.ContainsKey(cam.Key))
{
dicCameraObjs.Add(cam.Key, c);
}
}
}
/// <summary>
/// 获取Enum 枚举类型的注释
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public static string GetDescription(this Enum obj)
{
return(EnumDictionary.GetOrAdd(obj, (o) =>
{
var type = o.GetType();
FieldInfo field = type.GetField(Enum.GetName(type, o));
DescriptionAttribute descAttr = Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute)) as DescriptionAttribute;
if (descAttr == null)
{
return string.Empty;
}
return descAttr.Description;
}));
}
private void OnEnable()
{
if (dicFuzzyData == null && fuzzyDatas != null)
{
dicFuzzyData = new EnumDictionary <Membership, AnimationCurve>();
for (int i = 0; i < this.fuzzyDatas.Length; i++)
{
var key = (Membership)((int)fuzzyDatas[i].kind + (int)df_Fuzzy);
if (!dicFuzzyData.ContainsKey(key))
{
dicFuzzyData.Add(key, fuzzyDatas[i].membership);
}
}
}
}
// Private Method
#region Private Method
private void Init()
{
if (cameraDatas != null)
{
dicCameras = new EnumDictionary <CameraKind, CameraData>();
for (int i = 0; i < cameraDatas.Length; i++)
{
if (!dicCameras.ContainsKey(cameraDatas[i].kind))
{
dicCameras.Add(cameraDatas[i].kind, cameraDatas[i]);
cameraDatas[i].MappingCamera();
}
}
CreateCamera();
}
}
public void EnumDictionary_Values()
{
var enumDictionary = EnumDictionary.Create <ExpressionType, int>();
var values = Enum.GetValues(typeof(ExpressionType)).Cast <ExpressionType>().ToArray();
foreach (var val in values.Where(e => ((int)e) % 2 == 0))
{
enumDictionary.Add(val, (int)val);
}
var dictValues = enumDictionary.Values.ToArray();
foreach (var value in values.Cast <int>())
{
Assert.AreEqual(value % 2 == 0, dictValues.Contains(value));
}
}
public void EnumDictionary_ManOrBoy()
{
IDictionary <ExpressionType, bool> dictionary;
var values = Enum.GetValues(typeof(ExpressionType)).Cast <ExpressionType>().ToArray();
foreach (var setValue in values)
{
dictionary = EnumDictionary.Create <ExpressionType, bool>();
dictionary[setValue] = true;
foreach (var testValue in values)
{
Assert.AreEqual(testValue == setValue, dictionary.TryGetValue(testValue, out _));
}
}
}
// PERF: Expose the metrics as a struct that contains a reference to the long[] and provides
// dictionary-like APIs to reduce allocations.
public IReadOnlyDictionary <EntityMetric, TimeSpan> GetMetrics(IReactiveResource entity)
{
var entityMetrics = GetEntityMetrics(entity);
var results = EnumDictionary.Create <EntityMetric, TimeSpan>();
for (var i = 0; i < s_metricCount; ++i)
{
var metric = entityMetrics[i];
if (metric >= 0)
{
results[(EntityMetric)i] = new TimeSpan(metric);
}
}
// CONSIDER: Consider whether we need to create a wrapper.
return(new ReadOnlyDictionary <EntityMetric, TimeSpan>(results));
}
private static Func <Enum, string> GetEnumStringResolver(Type type)
{
var values = Enum.GetValues(type);
var dictionary = new EnumDictionary(values.Length);
for (int index = 0; index < values.Length; index++)
{
var value = values.GetValue(index);
#if DOTNETCORE
var info = type.GetTypeInfo().GetDeclaredField(value.ToString());
#else
var info = type.GetField(value.ToString());
#endif
var da = (EnumMemberAttribute[])info.GetCustomAttributes(typeof(EnumMemberAttribute), false);
var stringValue = da.Length > 0 ? da[0].Value : Enum.GetName(type, value);
dictionary.Add((Enum)value, stringValue);
}
#if DOTNETCORE
var isFlag = type.GetTypeInfo().GetCustomAttributes(typeof(FlagsAttribute), false).Any();
#else
var isFlag = type.GetCustomAttributes(typeof(FlagsAttribute), false).Length > 0;
#endif
return((e) =>
{
if (isFlag)
{
var list = new List <string>();
foreach (var kv in dictionary)
{
if (e.HasFlag(kv.Key))
{
list.Add(kv.Value);
}
}
return string.Join(",", list);
}
else
{
return dictionary[e];
}
});
}
public ActionResult ClassSubjectManagement(int classSubjectId)
{
try
{
using (var data = new Entities())
{
var subjectMaps = data.SubjectMaps.Where(x => x.CredentialId == UserInformation.UserInformationCredential.Id).ToList();
var classMaps = data.ClassMaps.Where(x => x.CredentialId == UserInformation.UserInformationCredential.Id).ToList();
var classSubject =
data.ClassSubjects.Where(
x =>
x.Id == classSubjectId && x.CredentialId == UserInformation.UserInformationCredential.Id)
.ToList()
.Select(
x =>
new ClassSubjectManagement()
{
ClassSubject = x,
SubjectId = subjectMaps.FirstOrDefault(y => y.Id == x.SubjectId)?.SubjectId,
ClassId = classMaps.FirstOrDefault(y => y.Id == x.ClassId)?.ClassId,
ClassName =
data.Classes.ToList().FirstOrDefault(
z => z.Id == classMaps.FirstOrDefault(y => y.Id == x.ClassId)?.ClassId)?
.ClassName ?? "",
SubjectName =
EnumDictionary.GetList <Subjects>().ToList()
.FirstOrDefault(
z =>
z.ItemId ==
subjectMaps.FirstOrDefault(y => y.Id == x.SubjectId)?.SubjectId)
?
.ItemName ?? ""
}).FirstOrDefault();
return(classSubject == null?View("Index") : View(classSubject));
}
}
catch (Exception ex)
{
ActivityLogger.Log(ex);
return(View("Index"));
}
}
public void EnumDictionaryFactory_Parameter_Validation()
{
try
{
EnumDictionary.Create <int, bool>();
Assert.Fail();
}
catch (ArgumentException e)
{
Assert.AreEqual(e.ParamName, "TKey");
}
try
{
EnumDictionary.Create <Foo, bool>();
Assert.Fail();
}
catch (ArgumentException e)
{
Assert.AreEqual(e.ParamName, "TKey");
}
try
{
EnumDictionary.Create <Bar, bool>();
Assert.Fail();
}
catch (ArgumentException e)
{
Assert.AreEqual(e.ParamName, "TKey");
}
try
{
EnumDictionary.Create <Baz, bool>();
Assert.Fail();
}
catch (ArgumentException e)
{
Assert.AreEqual(e.ParamName, "TKey");
}
}
// Property
#region Property
#endregion
// MonoBehaviour
#region MonoBehaviour
private void Awake()
{
dicFuzzyFunctions = new EnumDictionary <DF_FuzzySet, FuzzySet>();
dicFuzzyRules = new EnumDictionary <DF_FuzzyRule, FuzzyRule>();
for (int i = 0; i < fuzzyFunctions.Length; i++)
{
if (!dicFuzzyFunctions.ContainsKey(fuzzyFunctions[i].kind))
{
dicFuzzyFunctions.Add(fuzzyFunctions[i].kind, fuzzyFunctions[i].fuzzySet);
}
}
for (int i = 0; i < fuzzyRules.Length; i++)
{
if (!dicFuzzyRules.ContainsKey(fuzzyRules[i].kind))
{
dicFuzzyRules.Add(fuzzyRules[i].kind, fuzzyRules[i].fuzzyRule);
}
}
}
public override EnumDictionary <E, T> Inspect(string label, EnumDictionary <E, T> dict, object parent, DatabaseInspector inspectorWindow)
{
var names = Enum.GetNames(typeof(E));
if (dict == null || dict.Values.Length != names.Length)
{
var newValue = new T[names.Length];
if (dict != null && dict.Values.Length > 0)
{
Array.Copy(dict.Values, newValue, min(dict.Values.Length, newValue.Length));
}
dict.Values = newValue;
}
using (new VerticalScope(GUI.skin.box))
{
if (Foldout(_foldouts.Contains(dict), label, true, EditorStyles.boldLabel))
{
_foldouts.Add(dict);
}
else
{
_foldouts.Remove(dict);
}
if (_foldouts.Contains(dict))
{
for (var i = 0; i < names.Length; i++)
{
using (new VerticalScope(DatabaseInspector.ListItemStyle))
{
dict.Values[i] = (T)inspectorWindow.InspectMember(names[i], dict.Values[i], parent, typeof(T));
}
}
}
}
return(dict);
}
//--------------------------------------------------------------------------------------------------------------------------------
public bool Equals(EnumDictionary <TKey, TValue> rhs)
{
return(Raw.Equals(rhs.Raw));
}
public JsonResult GetUser(string username)
{
try
{
using (var data = new Entities())
{
var allClasses = data.Classes.Where(x => x.IsDeleted == false).ToList();
var allSubjects = EnumDictionary.GetList <Subjects>();
var userInformation =
data.Credentials.FirstOrDefault(x => x.IsDeleted == false && x.Username == username);
var mappedClassesRaw =
data.ClassMaps
.Where(x => x.IsDeleted == false && x.CredentialId == userInformation.Id).ToList();
var mappedSubjectsRaw =
data.SubjectMaps.Where(x => x.IsDeleted == false && x.CredentialId == userInformation.Id)
.ToList();
var mappedClasses =
allClasses.Select(
c =>
new
{
c,
MappingStatus = (mappedClassesRaw.FirstOrDefault(m => m.ClassId == c.Id) != null)
})
.OrderBy(x => x.c.ClassName)
.ToList();
var mappedSubjects =
allSubjects.Select(
s => new
{
s,
MappingStatus = (mappedSubjectsRaw.FirstOrDefault(m => m.SubjectId == s.ItemId) != null)
})
.OrderBy(x => x.s.ItemName)
.ToList();
return(new JsonResult()
{
Data =
new
{
Status = true,
Message = $"Found User",
Data =
new
{
UserInformation = userInformation,
MappedClasses = mappedClasses,
MappedSubject = mappedSubjects,
TotalClasses = mappedClasses.Count,
TotalSubjects = mappedSubjects.Count
}
},
JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
}
catch (Exception ex)
{
ActivityLogger.Log(ex);
return(new JsonResult()
{
Data = new { Status = false, Message = ex.Message, Data = string.Empty },
JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
}
// GET: ApiResultManagement
public JsonResult GetHelm()
{
try
{
using (var data = new Entities())
{
var classes = data.Classes.Where(x => x.IsDeleted == false).ToList();
var subjects = EnumDictionary.GetList <Subjects>();
var classMaps =
data.ClassMaps.Where(x => x.CredentialId == UserInformation.UserInformationCredential.Id && x.IsDeleted == false)
.ToList();
var subjectMaps =
data.SubjectMaps.Where(x => x.CredentialId == UserInformation.UserInformationCredential.Id && x.IsDeleted == false)
.ToList();
return(new JsonResult()
{
Data =
new
{
Status = true,
Message = $"Success",
Data =
new
{
Assessments =
data.Assessments.Where(x => x.IsDeleted == false)
.OrderBy(x => x.AssessmentName)
.ToList(),
Classes = classMaps
.ToList()
.Select(
x =>
new
{
x,
ClassName =
classes.FirstOrDefault(y => y.Id == x.ClassId)?
.ClassName ?? ""
}),
Subjects = subjectMaps
.ToList()
.Select(
x =>
new
{
x,
SubjectName =
subjects.FirstOrDefault(y => y.ItemId == x.SubjectId)?
.ItemName ?? ""
})
}
},
JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
}
catch (Exception ex)
{
ActivityLogger.Log(ex);
return(new JsonResult()
{
Data = new { Status = false, Message = ex.Message, Data = string.Empty },
JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
}
public string ValueString(EnumDictionary value)
{
return(value.ToString());
}
public void EnumDictionary_Bounds_Checks()
{
var enumDictionary = EnumDictionary.Create <ExpressionType, bool>();
var values = Enum.GetValues(typeof(ExpressionType)).Cast <ExpressionType>().ToArray();
try
{
enumDictionary.Add((ExpressionType)(-1), true);
Assert.Fail();
}
catch (ArgumentOutOfRangeException e)
{
Assert.AreEqual("key", e.ParamName);
}
try
{
enumDictionary.Add((ExpressionType)(values.Length), true);
Assert.Fail();
}
catch (ArgumentOutOfRangeException e)
{
Assert.AreEqual("key", e.ParamName);
}
try
{
enumDictionary[(ExpressionType)(-1)] = true;
Assert.Fail();
}
catch (ArgumentOutOfRangeException e)
{
Assert.AreEqual("key", e.ParamName);
}
try
{
enumDictionary[(ExpressionType)(values.Length)] = true;
Assert.Fail();
}
catch (ArgumentOutOfRangeException e)
{
Assert.AreEqual("key", e.ParamName);
}
try
{
var dummy = enumDictionary[(ExpressionType)(-1)];
Assert.Fail();
}
catch (ArgumentOutOfRangeException e)
{
Assert.AreEqual("key", e.ParamName);
}
try
{
var dummy = enumDictionary[(ExpressionType)(values.Length)];
Assert.Fail();
}
catch (ArgumentOutOfRangeException e)
{
Assert.AreEqual("key", e.ParamName);
}
try
{
enumDictionary.ContainsKey((ExpressionType)(-1));
Assert.Fail();
}
catch (ArgumentOutOfRangeException e)
{
Assert.AreEqual("key", e.ParamName);
}
try
{
enumDictionary.ContainsKey((ExpressionType)(values.Length));
Assert.Fail();
}
catch (ArgumentOutOfRangeException e)
{
Assert.AreEqual("key", e.ParamName);
}
try
{
enumDictionary.Contains(new KeyValuePair <ExpressionType, bool>((ExpressionType)(-1), true));
Assert.Fail();
}
catch (ArgumentOutOfRangeException e)
{
Assert.AreEqual("item", e.ParamName);
}
try
{
enumDictionary.Contains(new KeyValuePair <ExpressionType, bool>((ExpressionType)(values.Length), true));
Assert.Fail();
}
catch (ArgumentOutOfRangeException e)
{
Assert.AreEqual("item", e.ParamName);
}
try
{
enumDictionary.Remove((ExpressionType)(-1));
Assert.Fail();
}
catch (ArgumentOutOfRangeException e)
{
Assert.AreEqual("key", e.ParamName);
}
try
{
enumDictionary.Remove((ExpressionType)(values.Length));
Assert.Fail();
}
catch (ArgumentOutOfRangeException e)
{
Assert.AreEqual("key", e.ParamName);
}
try
{
enumDictionary.Remove(new KeyValuePair <ExpressionType, bool>((ExpressionType)(-1), true));
Assert.Fail();
}
catch (ArgumentOutOfRangeException e)
{
Assert.AreEqual("item", e.ParamName);
}
try
{
enumDictionary.Remove(new KeyValuePair <ExpressionType, bool>((ExpressionType)(values.Length), true));
Assert.Fail();
}
catch (ArgumentOutOfRangeException e)
{
Assert.AreEqual("item", e.ParamName);
}
try
{
enumDictionary.CopyTo(array: null, -1);
Assert.Fail();
}
catch (ArgumentNullException e)
{
Assert.AreEqual("array", e.ParamName);
}
try
{
enumDictionary.CopyTo(new KeyValuePair <ExpressionType, bool> [1], -1);
Assert.Fail();
}
catch (ArgumentOutOfRangeException e)
{
Assert.AreEqual("index", e.ParamName);
}
enumDictionary = EnumDictionary.Create <ExpressionType, bool>();
// This is valid because although the index is past the last array slot,
// there are zero elements. This is the same behavior as the CopyTo in
// System.Collections.Generic.Dictionary<TKey, TValue>
enumDictionary.CopyTo(new KeyValuePair <ExpressionType, bool> [1], 1);
try
{
enumDictionary.CopyTo(new KeyValuePair <ExpressionType, bool> [1], 3);
Assert.Fail();
}
catch (ArgumentOutOfRangeException e)
{
Assert.AreEqual("index", e.ParamName);
}
ExpressionType val0 = 0;
ExpressionType val1 = (ExpressionType)1;
enumDictionary.Add(val0, true);
enumDictionary.Add(val1, true);
try
{
enumDictionary.CopyTo(new KeyValuePair <ExpressionType, bool> [1], 0);
Assert.Fail();
}
catch (ArgumentException e)
{
Assert.AreEqual(typeof(ArgumentException), e.GetType());
}
}
CreateMaterialPropertiesTable(IFactory <int, INoise3D> noiseFactory)
{
Contracts.Requires.That(noiseFactory != null);
var textureAtlasBuilder = new EnumKeyTextureAtlasBuilder <TerrainTexture>(
atlasPixelDimensions: new Index2D(128, 128),
swatchPixelDimensions: new Index2D(16, 16),
invertXAxis: true,
invertYAxis: false);
textureAtlasBuilder.AddSwatch(TerrainTexture.None, new Index2D(0, 0));
textureAtlasBuilder.AddSwatch(TerrainTexture.GrassFull, new Index2D(0, 1));
textureAtlasBuilder.AddSwatch(TerrainTexture.GrassTop, new Index2D(1, 1));
textureAtlasBuilder.AddSwatch(TerrainTexture.GrassBottom, new Index2D(2, 1));
textureAtlasBuilder.AddSwatch(TerrainTexture.Dirt, new Index2D(0, 2));
textureAtlasBuilder.AddSwatch(TerrainTexture.Stone, new Index2D(0, 3));
var textureAtlas = textureAtlasBuilder.Build();
var materialPropertiesTable =
EnumDictionary.Create <TerrainMaterial, ITerrainMaterialProperties <TSurfaceData> >();
float areaThreshold = .8f;
var noiseDistorter = NoiseDistorter.New().Frequency(100, 100, 100);
var noTexture = new TextureSwatchSurfaceGenerator <TerrainVoxel, TSurfaceData>(
textureAtlas[TerrainTexture.None]);
materialPropertiesTable[TerrainMaterial.Air] = new TerrainMaterialProperties <TSurfaceData>(
false,
new ConstantSurfaceGenerator <TerrainVoxel, TSurfaceData, Color>(Color.Pink),
noTexture);
materialPropertiesTable[TerrainMaterial.Dirt] = new TerrainMaterialProperties <TSurfaceData>(
true,
new ConstantSurfaceGenerator <TerrainVoxel, TSurfaceData, Color>(new Color(120, 96, 56)),
new AreaThresholdSurfaceGenerator <TerrainVoxel, TSurfaceData, Vector2>(
new NoiseSeedSurfaceGenerator <TerrainVoxel, TSurfaceData, Vector2>(
new SeedSwitchSurfaceGenerator <TerrainVoxel, TSurfaceData, Vector2>(
noTexture,
new SeedRangeSurfaceGenerator <TerrainVoxel, TSurfaceData, Vector2>(
.85f, 1f, new TextureSwatchSurfaceGenerator <TerrainVoxel, TSurfaceData>(
textureAtlas[TerrainTexture.Dirt]))),
noiseFactory,
noiseDistorter),
noTexture,
areaThreshold));
materialPropertiesTable[TerrainMaterial.Grass] = new TerrainMaterialProperties <TSurfaceData>(
true,
new ConstantSurfaceGenerator <TerrainVoxel, TSurfaceData, Color>(new Color(72, 160, 72)),
new AreaThresholdSurfaceGenerator <TerrainVoxel, TSurfaceData, Vector2>(
new NoiseSeedSurfaceGenerator <TerrainVoxel, TSurfaceData, Vector2>(
new SeedSwitchSurfaceGenerator <TerrainVoxel, TSurfaceData, Vector2>(
noTexture,
new SeedRangeSurfaceGenerator <TerrainVoxel, TSurfaceData, Vector2>(
.85f, 1f, new TextureSwatchSurfaceGenerator <TerrainVoxel, TSurfaceData>(
textureAtlas[TerrainTexture.GrassFull]))),
noiseFactory,
noiseDistorter),
noTexture,
areaThreshold));
materialPropertiesTable[TerrainMaterial.Stone] = new TerrainMaterialProperties <TSurfaceData>(
true,
new ConstantSurfaceGenerator <TerrainVoxel, TSurfaceData, Color>(Color.Gray),
new AreaThresholdSurfaceGenerator <TerrainVoxel, TSurfaceData, Vector2>(
new NoiseSeedSurfaceGenerator <TerrainVoxel, TSurfaceData, Vector2>(
new SeedSwitchSurfaceGenerator <TerrainVoxel, TSurfaceData, Vector2>(
noTexture,
new SeedRangeSurfaceGenerator <TerrainVoxel, TSurfaceData, Vector2>(
.85f, 1f, new TextureSwatchSurfaceGenerator <TerrainVoxel, TSurfaceData>(
textureAtlas[TerrainTexture.Stone]))),
noiseFactory,
noiseDistorter),
noTexture,
areaThreshold));
////materialPropertiesTable[TerrainMaterial.Coal] = new TerrainMaterialProperties<TSurfaceData>(
//// true,
//// new ConstantSurfaceGenerator<TerrainVoxel, TSurfaceData, Color>(Color.Black),
//// noTexture);
////materialPropertiesTable[TerrainMaterial.Iron] = new TerrainMaterialProperties<TSurfaceData>(
//// true,
//// new ConstantSurfaceGenerator<TerrainVoxel, TSurfaceData, Color>(Color.DarkGray),
//// noTexture);
////materialPropertiesTable[TerrainMaterial.Gold] = new TerrainMaterialProperties<TSurfaceData>(
//// true,
//// new ConstantSurfaceGenerator<TerrainVoxel, TSurfaceData, Color>(Color.Gold),
//// noTexture);
////materialPropertiesTable[TerrainMaterial.Diamond] = new TerrainMaterialProperties<TSurfaceData>(
//// true,
//// new ConstantSurfaceGenerator<TerrainVoxel, TSurfaceData, Color>(Color.BlueViolet),
//// noTexture);
EnumDictionary.ThrowIfMissingEnumKey(materialPropertiesTable);
return(materialPropertiesTable);
}
public JsonResult GetClassSubjects()
{
try
{
var credentialId = UserInformation.UserInformationCredential.Id;
using (var data = new Entities())
{
var activeSession = data.EducationalPeriods.FirstOrDefault(x => x.IsActive && !x.IsDeleted);
if (activeSession == null)
{
return new JsonResult()
{
Data =
new
{
Status = false,
Message =
$"Please check if the Administrator has created an Active Session Active Sub-Session"
},
JsonRequestBehavior = JsonRequestBehavior.AllowGet
}
}
;
var activeSubSession = data.SubEducationalPeriods.FirstOrDefault(x => x.IsActive && !x.IsDeleted && x.EducationalPeriodId == activeSession.Id);
if (activeSubSession == null)
{
return new JsonResult()
{
Data =
new
{
Status = false,
Message = $"Please check if the Administrator has created an Active Sub-Session"
},
JsonRequestBehavior = JsonRequestBehavior.AllowGet
}
}
;
var listOfSubjects = EnumDictionary.GetList <Subjects>();
var listOfClasses = data.Classes.Where(x => x.IsDeleted == false).ToList();
var subjectMaps = data.SubjectMaps.Where(x => x.CredentialId == credentialId).ToList();
var classMaps = data.ClassMaps.Where(x => x.CredentialId == credentialId).ToList();
var classSubjectRaw =
data.ClassSubjects.Where(
x =>
!x.IsDeleted && x.SessionId == activeSession.Id && x.SubSessionId == activeSubSession.Id &&
x.CredentialId == credentialId)
.AsEnumerable()
.Select(
x =>
new
{
x,
subjectMaps.FirstOrDefault(y => y.Id == x.SubjectId)?.SubjectId,
classMaps.FirstOrDefault(y => y.Id == x.ClassId)?.ClassId
})
.ToList();
var classSubjects = classSubjectRaw
.Select(c => new
{
c.x,
NameOfClassSubject =
$"{listOfClasses.FirstOrDefault(x => x.Id == c.ClassId)?.ClassName} {listOfSubjects.FirstOrDefault(x => x.ItemId == c.SubjectId)?.ItemName}",
MemberResultNumber = data.ClassSubjectMemberResults.Count(x => x.ClassSubjectId == c.x.Id)
}).ToList();
return(new JsonResult()
{
Data = new { Status = true, Message = $"Successful", Data = classSubjects },
JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
}
catch (Exception ex)
{
ActivityLogger.Log(ex);
return(new JsonResult()
{
Data = new { Status = false, Message = ex.Message, Data = string.Empty },
JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
}
public void Dictionary_Init()
{
CompareEnumTypeDictionary = new EnumDictionary <SpawnerType.TileType, Tile>();
}
public ActionResult <IDictionary <string, string> > ErrorCodes()
{
return(Ok(EnumDictionary.Of <ErrorCode>()));
}
public void Dictionary_Init()
{
CompareEnumTypeDictionary = new EnumDictionary <SpawnerType.EnemyType, GameObject>();
}
