/// <summary>
/// Register a new Item to the GDE database.
/// </summary>
/// <param name="schema">Name of the Schema this Item should be added to.</param>
/// <param name="itemName">The Name of the Item to create.</param>
/// <param name="fieldNames">If set, specify into what Fields the values should be populated.</param>
/// <param name="fieldTypes">The type of the field.</param>
/// <param name="fieldValues">Optionally fill the newly created Items with values in the specified Fields.</param>
/// <param name="save">Saves changes at the end by default.</param>
public static void CreateItem(string schema, string itemName, string[] fieldNames = null,
object[] fieldValues = null, GDEFieldType[] fieldTypes = null, bool save = true)
{
//check if Schema already contains an Item with the same name
if(CheckHasItem(itemName, schema, true, false)) return;
//register Item
GDEDataManager.RegisterItem(schema, itemName);
//skip rest if no field names or values set
if(fieldNames.Length == 0 || fieldValues.Length == 0) return;
//set fields and values
for(int i = 0; i < fieldNames.Length; i++)
{
GDEFieldType currFieldType = fieldTypes == null || fieldTypes.Length == 0
? ParseFieldValueType(fieldValues[i])
: ParseFieldValueTypeIfNone(fieldValues[i], fieldTypes[i]);
if(!CheckHasField(fieldNames[i], schema)) return;
if(!HasField(fieldNames[i], schema)) return;
SetFieldValue(itemName, fieldNames[i], fieldValues[i], currFieldType);
}
//check if Item exists now
if(!HasItem(itemName, schema))
{
UnityEngine.Debug.LogError("Failed to create Item " + itemName + " into " + schema + "!");
return;
}
if(save) Save();
}
/// <summary>
/// Check wheter the type of the field to access is actually of the same type as the given value.
/// </summary>
/// <param name="supposedType">What type the field should be.</param>
/// <returns></returns>
public static bool CheckFieldType(string itemName, string fieldName, GDEFieldType supposedType, string specifySchema = "")
{
GDEFieldType fieldType = GetFieldType(itemName, fieldName, specifySchema);
if(fieldType != supposedType)
{
UnityEngine.Debug.LogError("Field \"" + fieldName + "\"(" + fieldType.ToString()
+ ") isn't of type " + supposedType.ToString() + "!");
return false;
}
return true;
}
#pragma warning disable CS0618 // Type or member is obsolete
/// <summary>
/// Tries to set the value for any Field.
/// </summary>
/// <param name="fieldValue">Ensure that the object is of the same type as the given fieldType.</param>
public static void SetFieldValue(string itemName, string fieldName,
object fieldValue, GDEFieldType fieldType = GDEFieldType.None)
{
if(fieldValue == null)
{
UnityEngine.Debug.LogError("Field Value is null while trying to set Field Value for "
+ fieldName + " on " + itemName + "!");
return;
}
GDEFieldType selFieldType = ParseFieldValueTypeIfNone(fieldValue, fieldType);
switch(fieldValue.GetType().ToString().Replace("System.", ""))
{
case "Int16":
case "Int64":
fieldValue = Convert.ToInt32(fieldValue);
break;
}
try
{
switch(selFieldType)
{
case GDEFieldType.Bool:
GDEDataManager.SetBool(itemName, fieldName, (bool)fieldValue);
break;
case GDEFieldType.BoolList:
GDEDataManager.SetBoolList(itemName, fieldName, (List<bool>)fieldValue);
break;
case GDEFieldType.BoolTwoDList:
GDEDataManager.SetBoolTwoDList(itemName, fieldName, (List<List<bool>>)fieldValue);
break;
case GDEFieldType.Int:
GDEDataManager.SetInt(itemName, fieldName, (int)fieldValue);
break;
case GDEFieldType.IntList:
GDEDataManager.SetIntList(itemName, fieldName, (List<int>)fieldValue);
break;
case GDEFieldType.IntTwoDList:
GDEDataManager.SetIntTwoDList(itemName, fieldName, (List<List<int>>)fieldValue);
break;
case GDEFieldType.Float:
GDEDataManager.SetFloat(itemName, fieldName, (float)fieldValue);
break;
case GDEFieldType.FloatList:
GDEDataManager.SetFloatList(itemName, fieldName, (List<float>)fieldValue);
break;
case GDEFieldType.FloatTwoDList:
GDEDataManager.SetFloatTwoDList(itemName, fieldName, (List<List<float>>)fieldValue);
break;
case GDEFieldType.String:
GDEDataManager.SetString(itemName, fieldName, (string)fieldValue);
break;
case GDEFieldType.StringList:
GDEDataManager.SetStringList(itemName, fieldName, (List<string>)fieldValue);
break;
case GDEFieldType.StringTwoDList:
GDEDataManager.SetStringTwoDList(itemName, fieldName, (List<List<string>>)fieldValue);
break;
case GDEFieldType.Vector2:
GDEDataManager.SetVector2(itemName, fieldName, (Vector2)fieldValue);
break;
case GDEFieldType.Vector2List:
GDEDataManager.SetVector2List(itemName, fieldName, (List<Vector2>)fieldValue);
break;
case GDEFieldType.Vector2TwoDList:
GDEDataManager.SetVector2TwoDList(itemName, fieldName, (List<List<Vector2>>)fieldValue);
break;
case GDEFieldType.Vector3:
GDEDataManager.SetVector3(itemName, fieldName, (Vector3)fieldValue);
break;
case GDEFieldType.Vector3List:
GDEDataManager.SetVector3List(itemName, fieldName, (List<Vector3>)fieldValue);
break;
case GDEFieldType.Vector3TwoDList:
GDEDataManager.SetVector3TwoDList(itemName, fieldName, (List<List<Vector3>>)fieldValue);
break;
case GDEFieldType.Vector4:
GDEDataManager.SetVector4(itemName, fieldName, (Vector4)fieldValue);
break;
case GDEFieldType.Vector4List:
GDEDataManager.SetVector4List(itemName, fieldName, (List<Vector4>)fieldValue);
break;
case GDEFieldType.Vector4TwoDList:
GDEDataManager.SetVector4TwoDList(itemName, fieldName, (List<List<Vector4>>)fieldValue);
break;
case GDEFieldType.Color:
GDEDataManager.SetColor(itemName, fieldName, (Color)fieldValue);
break;
case GDEFieldType.ColorList:
GDEDataManager.SetColorList(itemName, fieldName, (List<Color>)fieldValue);
break;
case GDEFieldType.ColorTwoDList:
GDEDataManager.SetColorTwoDList(itemName, fieldName, (List<List<Color>>)fieldValue);
break;
case GDEFieldType.GameObject:
GDEDataManager.SetGameObject(itemName, fieldName, (GameObject)fieldValue);
break;
case GDEFieldType.GameObjectList:
GDEDataManager.SetGameObjectList(itemName, fieldName, (List<GameObject>)fieldValue);
break;
case GDEFieldType.GameObjectTwoDList:
GDEDataManager.SetGameObjectTwoDList(itemName, fieldName, (List<List<GameObject>>)fieldValue);
break;
case GDEFieldType.Texture2D:
GDEDataManager.SetTexture2D(itemName, fieldName, (Texture2D)fieldValue);
break;
case GDEFieldType.Texture2DList:
GDEDataManager.SetTexture2DList(itemName, fieldName, (List<Texture2D>)fieldValue);
break;
case GDEFieldType.Texture2DTwoDList:
GDEDataManager.SetTexture2DTwoDList(itemName, fieldName, (List<List<Texture2D>>)fieldValue);
break;
case GDEFieldType.Material:
GDEDataManager.SetMaterial(itemName, fieldName, (Material)fieldValue);
break;
case GDEFieldType.MaterialList:
GDEDataManager.SetMaterialList(itemName, fieldName, (List<Material>)fieldValue);
break;
case GDEFieldType.MaterialTwoDList:
GDEDataManager.SetMaterialTwoDList(itemName, fieldName, (List<List<Material>>)fieldValue);
break;
case GDEFieldType.AudioClip:
GDEDataManager.SetAudioClip(itemName, fieldName, (AudioClip)fieldValue);
break;
case GDEFieldType.AudioClipList:
GDEDataManager.SetAudioClipList(itemName, fieldName, (List<AudioClip>)fieldValue);
break;
case GDEFieldType.AudioClipTwoDList:
GDEDataManager.SetAudioClipTwoDList(itemName, fieldName, (List<List<AudioClip>>)fieldValue);
break;
}
} catch(UnityException ex)
{
UnityEngine.Debug.LogError(string.Format(GDMConstants.ErrorSettingValue, GDMConstants.StringType, itemName, fieldName));
UnityEngine.Debug.LogError(ex.ToString());
}
}
/// <summary>
/// Only parse the object type if no GDEFieldType was provided.
/// </summary>
public static GDEFieldType ParseFieldValueTypeIfNone(object fieldValue, GDEFieldType fieldType = GDEFieldType.None)
{
return fieldType != GDEFieldType.None ? fieldType : ParseFieldValueType(fieldValue);
}
////////////
/// <summary>
/// Apply an operation to the given Field.
/// </summary>
/// <param name="itemName"></param>
/// <param name="fieldName"></param>
/// <param name="fieldType"></param>
/// <param name="operation">Wheter to add, subtract, multiply or divide the Field value. Alternatively only store the smallest or biggest of the two or override it with the second value.</param>
/// <param name="byValue"></param>
public static void GDEOperator(string itemName, string fieldName, GDEFieldType fieldType, GDEOperation operation, object byValue)
{
//if(!CheckFieldType(itemName, fieldName, fieldType)) return;
object prevValue = GetFieldValue(itemName, fieldName);
switch(fieldType)
{
case GDEFieldType.Int:
int tmpIntValue = Convert.ToInt32(prevValue);
int operateIntBy = Convert.ToInt32(byValue);
switch(operation)
{
case GDEOperation.Add:
tmpIntValue += operateIntBy;
break;
case GDEOperation.Subtract:
tmpIntValue -= operateIntBy;
break;
case GDEOperation.Multiply:
tmpIntValue *= operateIntBy;
break;
case GDEOperation.Divide:
tmpIntValue /= operateIntBy;
break;
case GDEOperation.Min:
tmpIntValue = Math.Min(tmpIntValue, operateIntBy);
break;
case GDEOperation.Max:
tmpIntValue = Math.Max(tmpIntValue, operateIntBy);
break;
case GDEOperation.Set:
tmpIntValue = operateIntBy;
break;
}
prevValue = tmpIntValue;
break;
case GDEFieldType.Float:
float tmpFloatValue = Convert.ToSingle(prevValue);
float operateFloatBy = Convert.ToSingle(byValue);
switch(operation)
{
case GDEOperation.Add:
tmpFloatValue += operateFloatBy;
break;
case GDEOperation.Subtract:
tmpFloatValue -= operateFloatBy;
break;
case GDEOperation.Multiply:
tmpFloatValue *= operateFloatBy;
break;
case GDEOperation.Divide:
tmpFloatValue /= operateFloatBy;
break;
case GDEOperation.Min:
tmpFloatValue = Mathf.Min(tmpFloatValue, operateFloatBy);
break;
case GDEOperation.Max:
tmpFloatValue = Mathf.Max(tmpFloatValue, operateFloatBy);
break;
case GDEOperation.Set:
tmpFloatValue = operateFloatBy;
break;
}
prevValue = tmpFloatValue;
break;
case GDEFieldType.Vector2:
Vector2 tmpV2Value = (Vector2)prevValue;
Vector2 operateV2By = (Vector2)byValue;
Vector2 v2Result = Vector2.zero;
switch(operation)
{
case GDEOperation.Add:
tmpV2Value += operateV2By;
break;
case GDEOperation.Subtract:
tmpV2Value -= operateV2By;
break;
case GDEOperation.Multiply:
v2Result.x = tmpV2Value.x * operateV2By.x;
v2Result.y = tmpV2Value.y * operateV2By.y;
tmpV2Value = v2Result;
break;
case GDEOperation.Divide:
v2Result.x = tmpV2Value.x / operateV2By.x;
v2Result.y = tmpV2Value.y / operateV2By.y;
tmpV2Value = v2Result;
break;
case GDEOperation.Min:
v2Result.x = Mathf.Min(tmpV2Value.x, operateV2By.x);
v2Result.y = Mathf.Min(tmpV2Value.y, operateV2By.y);
tmpV2Value = v2Result;
break;
case GDEOperation.Max:
v2Result.x = Mathf.Max(tmpV2Value.x, operateV2By.x);
v2Result.y = Mathf.Max(tmpV2Value.y, operateV2By.y);
tmpV2Value = v2Result;
break;
case GDEOperation.Set:
tmpV2Value = operateV2By;
break;
}
prevValue = tmpV2Value;
break;
case GDEFieldType.Vector3:
Vector3 tmpV3Value = (Vector3)prevValue;
Vector3 operateV3By = (Vector3)byValue;
Vector3 v3Result = Vector3.zero;
switch(operation)
{
case GDEOperation.Add:
tmpV3Value += operateV3By;
break;
case GDEOperation.Subtract:
tmpV3Value -= operateV3By;
break;
case GDEOperation.Multiply:
v3Result.x = tmpV3Value.x * operateV3By.x;
v3Result.y = tmpV3Value.y * operateV3By.y;
v3Result.z = tmpV3Value.z * operateV3By.z;
tmpV3Value = v3Result;
break;
case GDEOperation.Divide:
v3Result.x = tmpV3Value.x / operateV3By.x;
v3Result.y = tmpV3Value.y / operateV3By.y;
v3Result.z = tmpV3Value.z / operateV3By.z;
tmpV3Value = v3Result;
break;
case GDEOperation.Min:
v3Result.x = Mathf.Min(tmpV3Value.x, operateV3By.x);
v3Result.y = Mathf.Min(tmpV3Value.y, operateV3By.y);
v3Result.z = Mathf.Min(tmpV3Value.z, operateV3By.z);
tmpV3Value = v3Result;
break;
case GDEOperation.Max:
v3Result.x = Mathf.Max(tmpV3Value.x, operateV3By.x);
v3Result.y = Mathf.Max(tmpV3Value.y, operateV3By.y);
v3Result.z = Mathf.Max(tmpV3Value.z, operateV3By.z);
tmpV3Value = v3Result;
break;
case GDEOperation.Set:
tmpV3Value = operateV3By;
break;
}
prevValue = tmpV3Value;
break;
case GDEFieldType.Vector4:
Vector4 tmpV4Value = (Vector4)prevValue;
Vector4 operateV4By = (Vector4)byValue;
Vector4 v4Result = Vector4.zero;
switch(operation)
{
case GDEOperation.Add:
tmpV4Value += operateV4By;
break;
case GDEOperation.Subtract:
tmpV4Value -= operateV4By;
break;
case GDEOperation.Multiply:
v4Result.w = tmpV4Value.w * operateV4By.w;
v4Result.x = tmpV4Value.x * operateV4By.x;
v4Result.y = tmpV4Value.y * operateV4By.y;
v4Result.z = tmpV4Value.z * operateV4By.z;
tmpV4Value = v4Result;
break;
case GDEOperation.Divide:
v4Result.w = tmpV4Value.w / operateV4By.w;
v4Result.x = tmpV4Value.x / operateV4By.x;
v4Result.y = tmpV4Value.y / operateV4By.y;
v4Result.z = tmpV4Value.z / operateV4By.z;
tmpV4Value = v4Result;
break;
case GDEOperation.Min:
v4Result.w = Mathf.Min(tmpV4Value.w, operateV4By.w);
v4Result.x = Mathf.Min(tmpV4Value.x, operateV4By.x);
v4Result.y = Mathf.Min(tmpV4Value.y, operateV4By.y);
v4Result.z = Mathf.Min(tmpV4Value.z, operateV4By.z);
tmpV4Value = v4Result;
break;
case GDEOperation.Max:
v4Result.w = Mathf.Max(tmpV4Value.w, operateV4By.w);
v4Result.x = Mathf.Max(tmpV4Value.x, operateV4By.x);
v4Result.y = Mathf.Max(tmpV4Value.y, operateV4By.y);
v4Result.z = Mathf.Max(tmpV4Value.z, operateV4By.z);
tmpV4Value = v4Result;
break;
case GDEOperation.Set:
tmpV4Value = operateV4By;
break;
}
prevValue = tmpV4Value;
break;
default:
UnityEngine.Debug.LogError("Unsorted Field Type!");
break;
}
SetFieldValue(itemName, fieldName, prevValue, fieldType);
}
