Event Changes

Source/Game/GameEvent.cs

@@ -1,8 +1,9 @@
 using UnityEngine;
 using System.Collections.Generic;
+using System.Linq;
 
 [System.Serializable]
-public class GameEvent : ScriptableObject{
+public class GameEvent : ScriptableObject, JSONAble{
 
 	void Awake(){
 		if (args == null || args.Count != keys.Count) {
@@ -33,11 +34,10 @@ public object getParameter(string param){
 
 	public void setParameter(string param, object content){
 		param = param.ToLower();
-		object c = content;
-		if(c is System.ValueType || c is string){
-			c = ScriptableObject.CreateInstance<IsoUnityBasicType>();
-			((IsoUnityBasicType)c).Value = content;
-		}
+		object c = IsoUnityTypeFactory.Instance.getIsoUnityType(content);
+        if (c == null)
+            c = content;
+
 		if(args.ContainsKey(param))	args[param] = (Object)c;
 		else						args.Add(param, (Object)c);
 
@@ -47,8 +47,14 @@ public void setParameter(string param, object content){
 
 	public void removeParameter(string param){
 		param = param.ToLower();
-		if(args.ContainsKey(param))
-			args.Remove(param);
+        if (args.ContainsKey(param))
+        {
+            UnityEngine.Object v = args[param];
+            if (v is IsoUnityBasicType)
+                IsoUnityTypeFactory.Instance.Destroy(v as IsoUnityBasicType);
+
+            args.Remove(param);
+        }
 
 		this.keys = new List<string> (args.Keys);
 		this.values = new List<Object> (args.Values);
@@ -106,5 +112,57 @@ public override int GetHashCode ()
 	{
 		return !(ge1 == ge2);
 	}
+
+
+    public JSONObject toJSONObject()
+    {
+        JSONObject json = new JSONObject();
+        json.AddField("name", name);
+        JSONObject parameters = new JSONObject();
+        foreach (KeyValuePair<string, Object> entry in args)
+        {
+            if (entry.Value is JSONAble)
+            {
+                var jsonAble = entry.Value as JSONAble;
+                parameters.AddField(entry.Key, JSONSerializer.Serialize(jsonAble));
+            }
+            else
+            {
+                parameters.AddField(entry.Key, entry.Value.GetInstanceID());
+            }
+        }
+
+
+        json.AddField("parameters", parameters);
+        return json;
+    }
+
+    private static void destroyBasic(Dictionary<string, Object> args)
+    {
+        if (args == null || args.Count == 0)
+            return;
+
+        foreach (KeyValuePair<string, Object> entry in args)
+            if (entry.Value is IsoUnityBasicType)
+                IsoUnityBasicType.DestroyImmediate(entry.Value);
+    }
+
+    public void fromJSONObject(JSONObject json)
+    {
+        this.name = json["name"].ToString();
+
+        //Clean basic types
+        destroyBasic(this.args);
+
+        this.args = new Dictionary<string, Object>();
+
+        JSONObject parameters = json["parameters"];
+        foreach (string key in parameters.keys)
+        {
+            JSONObject param = parameters[key];
+            JSONAble unserialized = JSONSerializer.UnSerialize(param);
+            this.setParameter(key, unserialized);
+        }
+    }
 }
 

Source/Game/IsoUnityType.cs

@@ -0,0 +1,16 @@
+using UnityEngine;
+using System.Collections;
+
+public abstract class IsoUnityType : ScriptableObject, JSONAble
+{
+    public abstract bool canHandle(object o);
+    public abstract IsoUnityType clone();
+    public abstract object Value
+    {
+        get;
+        set;
+    }
+    public abstract JSONObject toJSONObject();
+
+    public abstract void fromJSONObject(JSONObject json);
+}

Source/Game/IsoUnityTypeFactory.cs

@@ -0,0 +1,51 @@
+using UnityEngine;
+using System.Collections.Generic;
+
+public abstract class IsoUnityTypeFactory 
+{
+    private static IsoUnityTypeFactory instance;
+    public static IsoUnityTypeFactory Instance
+    {
+        get
+        {
+            if (instance == null)
+                instance = new IsoUnityTypeFactoryImp();
+            return instance;
+        }
+    }
+    public abstract void Destroy(IsoUnityType i);
+    public abstract IsoUnityType getIsoUnityType(object c);
+
+    private class IsoUnityTypeFactoryImp : IsoUnityTypeFactory
+    {
+        private List<IsoUnityType> types;
+
+        public IsoUnityTypeFactoryImp()
+        {
+            types = new List<IsoUnityType>();
+            types.Add(ScriptableObject.CreateInstance<IsoUnityBasicType>());
+            types.Add(ScriptableObject.CreateInstance<IsoUnityCollectionType>());
+        }
+
+        public override void Destroy(IsoUnityType i)
+        {
+            IsoUnityType.DestroyImmediate(i);
+        }
+
+        public override IsoUnityType getIsoUnityType(object c)
+        {
+            IsoUnityType r = null;
+            foreach (IsoUnityType t in types)
+            {
+                if (t.canHandle(c))
+                {
+                    r = t.clone();
+                    r.Value = c;
+                    break;
+                }
+            }
+            return r;
+        }
+    }
+
+}