private static void WriteConfigAsJson(Type type, string folder)
{
var exportFields = type.GetFields(BindingFlags.Public | BindingFlags.Instance);
if (exportFields.Length == 0)
{
return;
}
_serializer.Config.CustomDateTimeFormatString = "G";
_serializer.AddConverter(new MyCustomEnumConverter());
_serializer.AddConverter(new MyDictionaryConverter());
var ins = InstanceUtility.InstanceOfType(type);
foreach (var field in exportFields)
{
if (field.GetValue(ins) == null)
{
var value = InstanceUtility.InstanceOfType(field.FieldType);
field.SetValue(ins, value);
}
XlsxNameAttribute xlxsName = (XlsxNameAttribute)Attribute.GetCustomAttribute(field, typeof(XlsxNameAttribute));
string jsonFilename = xlxsName != null ? xlxsName.xlsxName : field.Name;
var file = Path.Combine(folder, jsonFilename + ".json");
fsData data;
_serializer.TrySerialize(field.FieldType, field.GetValue(ins), out data).AssertSuccess();
WriteDataToJson(file, data);
if (TypeUtility.HasAttribute <LocaleAttribute>(field.FieldType))
{
file = Path.Combine(folder, jsonFilename + ".locale.json");
_serializer.TrySerialize(typeof(Dictionary <string, LocaleJsonObject>), localeDict, out data).AssertSuccess();
WriteDataToJson(file, data);
}
}
}
private static bool converter_added = false; //Before the serialization and the deserialization process we check if the serializer have the objects converter using this boolean
//Serialization process
public static string Serialize(object value, Type value_type, List <UnityEngine.Object> object_references)
{
//Lock the serialization object
lock (serialization_lock_obj)
{
//Add the converter in negative case
if (converter_added == false)
{
serializer.AddConverter(new ObjectConverter());
converter_added = true;
}
//Set the serializer object references context
if (object_references != null)
{
serializer.Context.Set <List <UnityEngine.Object> >(object_references);
}
//Serialize the value in a fsData
fsData data;
serializer.TrySerialize(value_type, value, out data).AssertSuccess();
//Insert the serialized data in the dic
data_dic[fsJsonPrinter.CompressedJson(data)] = data;
//Serialize the data in the JSON file
return(fsJsonPrinter.CompressedJson(data));
}
}
///Serialize to json
public static string Serialize(Type type, object value, bool pretyJson = false, List <UnityEngine.Object> objectReferences = null)
{
lock (serializerLock)
{
if (!init)
{
serializer.AddConverter(new fsUnityObjectConverter());
init = true;
}
//set the objectReferences context
if (objectReferences != null)
{
objectReferences.Clear(); //we clear the list since it will be populated by the converter.
serializer.Context.Set <List <UnityEngine.Object> >(objectReferences);
}
//serialize the data
fsData data;
//We override the UnityObject converter if we serialize a UnityObject directly.
//UnityObject converter will still be used for every serialized property found within the object though.
var overrideConverterType = typeof(UnityEngine.Object).RTIsAssignableFrom(type)? typeof(fsReflectedConverter) : null;
serializer.TrySerialize(type, overrideConverterType, value, out data).AssertSuccess();
//print data to json
if (pretyJson)
{
return(fsJsonPrinter.PrettyJson(data));
}
return(fsJsonPrinter.CompressedJson(data));
}
}
///Serialize to json
public static string Serialize(Type type, object value, bool pretyJson = false, List <UnityEngine.Object> objectReferences = null)
{
lock (serializerLock)
{
if (!init)
{
serializer.AddConverter(new fsUnityObjectConverter());
init = true;
}
//set the objectReferences context
if (objectReferences != null)
{
serializer.Context.Set <List <UnityEngine.Object> >(objectReferences);
}
//serialize the data
fsData data;
serializer.TrySerialize(type, value, out data).AssertSuccess();
cache[fsJsonPrinter.CompressedJson(data)] = data;
//print data to json
if (pretyJson)
{
return(fsJsonPrinter.PrettyJson(data));
}
return(fsJsonPrinter.CompressedJson(data));
}
}
static FullSerializerBackend()
{
Serializer = new fsSerializer();
Serializer.AddConverter(new UnityObjectConverter());
Serializer.AddConverter(new MethodInfoConverter());
fsConfig.SerializeAttributes = VFWSerializationLogic.Instance.SerializeMember;
fsConfig.IgnoreSerializeAttributes = VFWSerializationLogic.Instance.DontSerializeMember;
}
static FullSerializerBackend()
{
Serializer = new fsSerializer();
Serializer.AddConverter(new UnityObjectConverter());
Serializer.AddConverter(new MethodInfoConverter());
fsConfig.SerializeAttributes = VFWSerializationLogic.Instance.Attributes.SerializeMember;
fsConfig.IgnoreSerializeAttributes = VFWSerializationLogic.Instance.Attributes.DontSerializeMember;
}
public SerializationOperation()
{
objectReferences = new List <UnityObject>();
serializer = new fsSerializer();
serializer.AddConverter(new UnityObjectConverter());
serializer.AddConverter(new RayConverter());
serializer.AddConverter(new Ray2DConverter());
serializer.AddConverter(new NamespaceConverter());
serializer.AddConverter(new LooseAssemblyNameConverter());
serializer.Context.Set(objectReferences);
}
public string Export()
{
fsSerializer serializer = new fsSerializer();
serializer.AddConverter(new Vector3Converter());
serializer.AddConverter(new Vector2Converter());
serializer.AddConverter(new QuaternionConverter());
serializer.TrySerialize <BlueprintData>(this, out fsData data).AssertSuccessWithoutWarnings();
string json = fsJsonPrinter.CompressedJson(data);
return(Convert.ToBase64String(Zip(json)));
}
/// <summary>
/// Deserialize object with support for unity reference.
/// Unity reference will be handle from references
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="json"></param>
/// <returns></returns>
public static void Deserialize <T>(string json, ref T instance, List <Object> references)
{
try {
fsData data;
fsJsonParser.Parse(json, out data);
if (data != null)
{
fsSerializer fsS;
if (UnityObjectConverter.listObject != null)
{
fsS = new fsSerializer();
fsS.AddConverter(new UnityObjectConverter()
{
reference = references
});
}
else
{
UnityObjectConverter.listObject = references;
fsS = editorSerializer;
}
fsS.TryDeserialize <T>(data, ref instance);
if (UnityObjectConverter.listObject != null && references != null)
{
UnityObjectConverter.listObject = null;
}
}
}
catch (System.Exception ex) {
Debug.LogException(ex);
}
}
static FullSerializerSerializer() {
_serializer = new fsSerializer();
_serializer.AddConverter(new UnityObjectConverter());
#if !UNITY_4_3
_serializer.AddProcessor(new SerializationCallbackReceiverObjectProcessor());
#endif
}
/// <summary>
/// Deserialize object with support for unity reference and type converter if default type is missing.
/// Unity reference will be handle from references.
/// </summary>
/// <param name="json"></param>
/// <param name="type"></param>
/// <param name="references"></param>
/// <returns></returns>
public static object Deserialize(string json, System.Type type, List <Object> references)
{
object result = null;
try {
fsData data;
fsJsonParser.Parse(json, out data);
if (data != null)
{
fsSerializer fsS;
if (UnityObjectConverter.listObject != null)
{
fsS = new fsSerializer();
fsS.AddConverter(new UnityObjectConverter()
{
reference = references
});
}
else
{
UnityObjectConverter.listObject = references;
fsS = editorSerializer;
}
if (type != null)
{
if (data.IsDictionary)
{
var d = data.AsDictionary;
if (d.ContainsKey("$type"))
{
fsData fsD = d["$type"];
if (fsD.IsString)
{
System.Type t = TypeSerializer.Deserialize(fsD.AsString, false);
if (t == null)
{
d["$type"] = new fsData(type.FullName);
}
}
}
}
//fsS.TryDeserialize(data, type, ref result);
fsS.TryDeserialize(data, ref result);
}
else
{
fsS.TryDeserialize(data, ref result);
}
if (UnityObjectConverter.listObject != null && references != null)
{
UnityObjectConverter.listObject = null;
}
}
}
catch (System.Exception ex) {
Debug.LogException(ex);
}
return(result);
}
static FullSerializerSerializer()
{
_serializer = new fsSerializer();
_serializer.AddConverter(new UnityObjectConverter());
#if !UNITY_4_3
_serializer.AddProcessor(new SerializationCallbackReceiverObjectProcessor());
#endif
}
private static void GetJsonConverters(ref fsSerializer _serializer)
{
var converters = new List <fsConverter>(AllJsonConverters.GetAllJsonConverters());
foreach (var converter in converters)
{
_serializer.AddConverter(converter);
}
}
static JsonHelper()
{
serializer = new fsSerializer();
serializer.Config.EnablePropertySerialization = false;
editorSerializer = new fsSerializer();
editorSerializer.AddConverter(new UnityObjectConverter());
editorSerializer.Config.SerializeEnumsAsInteger = true;
editorSerializer.Config.EnablePropertySerialization = false;
}
private static object ReadConfigAsJson(Type type, string folder)
{
var ins = Activator.CreateInstance(type);
var exportFields = type.GetFields(BindingFlags.Public | BindingFlags.Instance);
if (exportFields.Length == 0)
{
return(ins);
}
_serializer.AddConverter(new MyCustomEnumConverter());
_serializer.AddConverter(new MyDictionaryConverter());
foreach (var field in exportFields)
{
XlsxNameAttribute xlxsName = (XlsxNameAttribute)Attribute.GetCustomAttribute(field, typeof(XlsxNameAttribute));
string jsonFilename = xlxsName != null ? xlxsName.xlsxName : field.Name;
var file = Path.Combine(folder, jsonFilename + ".json");
if (!File.Exists(file))
{
throw new Exception(string.Format("xlsx file {0} not exists", jsonFilename));
}
Console.WriteLine("read from config: " + jsonFilename);
FileStream fs = File.Open(file, FileMode.Open);
StringBuilder sb = new StringBuilder();
byte[] b = new byte[1024];
UTF8Encoding temp = new UTF8Encoding(true);
while (fs.Read(b, 0, b.Length) > 0)
{
sb.Append(temp.GetString(b));
}
fs.Close();
fsData data;
fsResult res = fsJsonParser.Parse(sb.ToString(), out data);
res.AssertSuccess();
object value = null;
_serializer.TryDeserialize(data, field.FieldType, ref value).AssertSuccess();
field.SetValue(ins, value);
}
return(ins);
}
public static string ToJSON(Dictionary <string, object> dict)
{
fsSerializer serializer = new fsSerializer();
serializer.AddConverter(new DictionaryConverter());
fsData data;
serializer.TrySerialize <Dictionary <string, object> >(dict, out data).AssertSuccessWithoutWarnings();
return(fsJsonPrinter.CompressedJson(data));
}
static SaveManager()
{
Serializer = new fsSerializer();
Serializer.AddConverter <fsGameObjectReferenceConverter>();
Serializer.AddConverter <fsAssetReferenceConverter>();
Serializer.AddConverter <fsComponentReferenceConverter>();
Converters = new Dictionary <Type, Func <SaveConverter> >
{
{ typeof(GameObject), () => new GameObjectConverter() },
{ typeof(Transform), () => new TransformConverter() },
{ typeof(MonoBehaviour), () => new MonoBehaviourConverter() },
{ typeof(Rigidbody), () => new RigidbodyConverter() },
{ typeof(BoxCollider), () => new BoxColliderConverter() },
{ typeof(SphereCollider), () => new SphereColliderConverter() },
{ typeof(CapsuleCollider), () => new CapsuleColliderConverter() },
{ typeof(MeshCollider), () => new MeshColliderConverter() },
{ typeof(MeshFilter), () => new MeshFilterConverter() },
{ typeof(AudioSource), () => new AudioSourceConverter() },
{ typeof(Animator), () => new AnimatorConverter() },
{ typeof(Animation), () => new AnimationConverter() },
{ typeof(CharacterController), () => new CharacterControllerConverter() },
{ typeof(Camera), () => new CameraConverter() },
{ typeof(MeshRenderer), () => new RendererConverter <MeshRenderer>() },
{ typeof(LineRenderer), () => new RendererConverter <LineRenderer>() },
{ typeof(SkinnedMeshRenderer), () => new SkinnedMeshRendererConverter() },
{ typeof(TrailRenderer), () => new TrailRendererConverter() },
{ typeof(ParticleRenderer), () => new ParticleRendererConverter() },
{ typeof(Light), () => new LightConverter() },
{ typeof(ParticleAnimator), () => new ParticleAnimatorConverter() },
{ typeof(ParticleEmitter), null },
{ typeof(GUILayer), null },
{ typeof(AudioListener), null },
{ typeof(ClothRenderer), null },
{ typeof(Cloth), null },
{ typeof(Joint), null },
};
SaveLocation = Path.Combine(Application.dataPath, "SaveData");
}
public BetterSerializer()
{
serializer = new fsSerializer();
serializer.AddConverter <UnityObjectConverter>();
Logic = SerializationLogic.Default;
fsSerializer.Config = new fsConfig(
Logic.Attributes.SerializeMember,
Logic.Attributes.DontSerializeMember,
false, Debug.Log, true
);
}
private GeoJsonRoot ParseData(string geoJsonData)
{
fsSerializer serializer = new fsSerializer();
serializer.Config.GetJsonNameFromMemberName = GetJsonNameFromMemberName;
serializer.AddConverter(new Converter());
fsData data = null;
data = fsJsonParser.Parse(geoJsonData);
// step 2: deserialize the data
GeoJsonRoot deserialized = null;
serializer.TryDeserialize(data, ref deserialized).AssertSuccessWithoutWarnings();
return(deserialized);
}
/// <summary>
/// Serialize object with support for unity reference.
/// Unity reference will saved to reference.
/// </summary>
/// <param name="obj"></param>
/// <param name="Indented"></param>
/// <param name="references"></param>
/// <returns></returns>
public static string Serialize(object obj, bool Indented, List <Object> references)
{
//Clear reference if its not null.
if (references != null)
{
references.Clear();
}
fsData data;
//Check if currently is serializing mostly this will false.
//This only to handle unity reference serialization.
if (UnityObjectConverter.listObject != null)
{
//Make new serializer.
fsSerializer s = new fsSerializer();
//Add new UnityObjectConverter so unity reference object will serialize and saved to list.
s.AddConverter(new UnityObjectConverter()
{
reference = references
});
//Make sure Enum type serialze to int so any changed made to enum will not lose.
s.Config.SerializeEnumsAsInteger = true;
//Disable property serialization so this save more performance and memory.
s.Config.EnablePropertySerialization = false;
//Try serializing object
s.TrySerialize(obj, out data);
}
else
{
if (references != null)
{
UnityObjectConverter.listObject = references;
}
editorSerializer.TrySerialize(obj, out data);
if (references != null)
{
UnityObjectConverter.listObject = null;
}
}
if (Indented)
{
return(fsJsonPrinter.PrettyJson(data));
}
return(fsJsonPrinter.CompressedJson(data));
}
public static void Deserialize <T>(string json, ref T instance, SerializedData serializedData)
{
try {
fsData data;
fsJsonParser.Parse(json, out data);
if (data != null)
{
fsSerializer serializer = new fsSerializer();
serializer.AddConverter(new ObjectConverter()
{
data = serializedData
});
serializer.TryDeserialize <T>(data, ref instance);
}
} catch (System.Exception ex) {
Debug.LogException(ex);
}
}
public static T FromJSON <T>(string payload) where T : new()
{
fsSerializer serializer = new fsSerializer();
serializer.AddConverter(new DateTimeConverter());
fsData data = fsJsonParser.Parse(payload);
T item = new T();
JSONKey jsonKey = (JSONKey)System.Attribute.GetCustomAttribute(typeof(T), typeof(JSONKey));
string key = jsonKey.Single;
if (data.AsDictionary.ContainsKey(key))
{
fsData itemData = data.AsDictionary[key];
serializer.TryDeserialize <T>(itemData, ref item).AssertSuccessWithoutWarnings();
}
return(item);
}
public static string Serialize(object obj, bool Indented, SerializedData serializedData)
{
fsData data;
//Make new serializer.
fsSerializer s = new fsSerializer();
//Add new UnityObjectConverter so unity reference object will serialize and saved to list.
s.AddConverter(new ObjectConverter()
{
data = serializedData
});
//Make sure Enum type serialze to int so any changed made to enum will not lose.
s.Config.SerializeEnumsAsInteger = true;
//Disable property serialization so this save more performance and memory.
s.Config.EnablePropertySerialization = false;
//Try serializing object
s.TrySerialize(obj, out data);
if (Indented)
{
return(fsJsonPrinter.PrettyJson(data));
}
return(fsJsonPrinter.CompressedJson(data));
}
static JsonSerializer()
{
_serializer = new fsSerializer();
_serializer.Config = new fsConfig()
{
SerializeEnumsAsInteger = true,
IgnoreSerializeAttributes = new Type[]
{
typeof(IgnoreCustomSerializationAttribute),
typeof(NonSerializedAttribute),
typeof(fsIgnoreAttribute)
},
SerializeAttributes = new Type[]
{
typeof(CustomSerializationAttribute),
typeof(UnityEngine.SerializeField),
typeof(fsPropertyAttribute)
}
};
_engineObjectConvertor = new fsUnityEngineObjectConverter();
_serializer.AddConverter(_engineObjectConvertor);
}
// -------------------------------------------------------------------------------
public void Initialise()
{
mSerialiser = new fsSerializer();
mSerialiser.AddConverter(new UnityObjectConverter());
mSerialiser.Context.Set(UnityObjectReferences);
}
// Use this for initialization
void Start()
{
// MIN 51.579687, -0.341837
// MAX 51.580780, -0.333930
//const float minLat = 51.579687f;
//const float maxLat = 51.580780f;
//const float minLon = -0.341837f;
//const float maxLon = -0.333930f;
float maxLat = 51.5140574994f;
float maxLon = -0.1145303249f;
float minLat = 51.5073134351f;
float minLon = -0.1295164166f;
float[][][] TileBounds = new float[][][]
{
new float[][]
{
new float[] { maxLon, maxLat, 0.0f },
new float[] { minLon, minLat, 0.0f },
}
};
// Can get the OSM data using something like the following..
var httpStr = @"http://overpass-api.de/api/interpreter?data=[out:json];(node[""building""](51.579687,-0.341837,51.580780,-0.333930);way[""building""](51.579687,-0.341837,51.580780,-0.333930);relation[""building""](51.579687,-0.341837,51.580780,-0.333930););out body;>;out skel qt;";
//var geoJson = Resources.Load("santander") as TextAsset;
var geoJson = Resources.Load("london2") as TextAsset;
fsSerializer serializer = new fsSerializer();
serializer.Config.GetJsonNameFromMemberName = GetJsonNameFromMemberName;
serializer.AddConverter(new Converter());
fsData data = null;
data = fsJsonParser.Parse(geoJson.text);
// step 2: deserialize the data
GeoJsonRoot deserialized = null;
try
{
serializer.TryDeserialize(data, ref deserialized).AssertSuccessWithoutWarnings();
}
catch (Exception ex)
{
int x = 3;
}
Debug.Log("Number of features = " + deserialized.features.Count());
var buildings = deserialized.features.Where(f => f.properties != null && f.properties.tags.building != null);
// Need to know the centre of the 'tile' so we can create the buildings at
// the origin and then translate to the correct positions.
// When we are calling an API we will know the lat lon of the requested tile
// until then we can use a bounding box around all of the buildings..
//var tb = GetBoundingBoxForBuilding(buildings.First());
//foreach (var building in buildings)
//{
// if (building == buildings.First())
// continue;
// var bounds = GetBoundingBoxForBuilding(building);
// if (bounds == null)
// continue;
// tb.Value.Encapsulate(bounds.Value);
//}
// Use the centre of the tile bounding box
var tb = GetBoundingBox(TileBounds);
int buildingCount = 0;
foreach (var building in buildings)
{
try
{
if (++buildingCount != 1)
{
continue;
}
if (building.geometry.coordinates == null)
{
continue;
}
foreach (var coords in building.geometry.coordinates)
{
// Create Vector2 vertices
List <Vector2> verts = new List <Vector2>();
foreach (var crd in coords)
{
// remember lat/lon are reversed in geoJSON
verts.Add(GM.LatLonToMeters(crd[1], crd[0]));
}
// Create the Vector3 vertices -
// So, x corresponds to latitude
// z corresponds to longitude
List <Vector3> verts3 = verts.Select(v => v.ToVector3xz()).ToList();
// Calculate axis aligned bounding box for polygon
var bound = new Bounds(verts3[0], Vector3.zero);
foreach (var vtx in verts3)
{
bound.Encapsulate(vtx);
}
// Move the polygon to the origin by subtracting the centre of the bounding box from
// each vertex.
verts = verts3.Select(vtx => (vtx - bound.center).ToVector2xz()).ToList();
Debug.Log(string.Format("NUM VERTS (before triangulation) = {0}", verts.Count));
// Work out the height of the building either from height or estimate from
// number of levels or failing that, just one level..
const float oneLevel = 16.0f;
int numLevels = 1;
if (!string.IsNullOrEmpty(building.properties.tags.building_levels))
{
numLevels = int.Parse(building.properties.tags.building_levels);
}
var mesh = Triangulator.CreateMesh(verts.ToArray(), numLevels * oneLevel);
var g = new GameObject();
g.AddComponent(typeof(MeshFilter));
g.AddComponent(typeof(MeshRenderer));
// If you want to get flat shading then you need a unique vertex for each
// face. I haven't processed the data like that so have run this code as a post
// process to generate the required vertices
// (see http://answers.unity3d.com/questions/798510/flat-shading.html)
Vector3[] oldVerts = mesh.vertices;
int[] triangles = mesh.triangles;
Vector3[] vertices = new Vector3[triangles.Length];
for (int i = 0; i < triangles.Length; i++)
{
vertices[i] = oldVerts[triangles[i]];
triangles[i] = i;
}
mesh.vertices = vertices;
mesh.triangles = triangles;
mesh.RecalculateBounds();
mesh.RecalculateNormals();
g.GetComponent <MeshFilter>().mesh = mesh;
var dist = bound.center - tb.Value.center;
// also, translate the building in y by half of its height..
//dist.y +=
g.transform.Translate(dist);
Material m = new Material(Shader.Find("Standard"));
m.color = Color.grey;
if (building.properties.tags != null)
{
if (!string.IsNullOrEmpty(building.properties.tags.name))
{
g.name = building.properties.tags.name;
}
else if (!string.IsNullOrEmpty(building.properties.tags.addrhousename))
{
g.name = building.properties.tags.addrhousename;
}
else if (!string.IsNullOrEmpty(building.properties.tags.addrstreet))
{
g.name = building.properties.tags.addrstreet;
}
}
g.GetComponent <MeshRenderer>().material = m;
g.transform.parent = gameObject.transform;
}
}
catch (Exception ex)
{
Debug.Log(string.Format("Building load failed"));
}
}
// Now generate a plane and texture it with a map image..
//var tb = GetBoundingBox(TileBounds);
var poly = tb.Value.ToPolygonFromBounds();
// Centre on the origin..
var polyArray = poly.ToList().Select(p => (p.ToVector3xz() - tb.Value.center).ToVector2xz());
var planeMesh = Triangulator.CreateMesh(polyArray.ToArray());
// Set the UVs:
//Vector2[] uvs = new Vector2[4];
//uvs[0] = new Vector2(0.0f, 0.0f);
//uvs[1] = new Vector2(0.0f, 1.0f);
//uvs[2] = new Vector2(1.0f, 1.0f);
//uvs[3] = new Vector2(1.0f, 0.0f);
{
Vector3[] old = planeMesh.vertices;
int[] triangles = planeMesh.triangles;
Vector3[] vertices = new Vector3[triangles.Length];
for (int i = 0; i < triangles.Length; i++)
{
vertices[i] = old[triangles[i]];
triangles[i] = i;
}
}
//planeMesh.uv = uvs;
planeMesh.RecalculateNormals();
planeMesh.RecalculateBounds();
var gobj = new GameObject();
gobj.name = "Tile Plane";
gobj.AddComponent(typeof(MeshFilter));
gobj.AddComponent(typeof(MeshRenderer));
gobj.GetComponent <MeshFilter>().mesh = planeMesh;
Material mt = new Material(Shader.Find("Standard"));
mt.color = Color.white;
gobj.GetComponent <MeshRenderer>().material = mt;
//Texture my_img = (Texture)Resources.Load("harrowtestimg");
//gobj.GetComponent<MeshRenderer>().material.mainTexture = my_img;
}
/// <summary>
/// Register the given converter for usage in the serializer.
/// </summary>
public static void AddConverter(fsConverter converter)
{
_serializer.AddConverter(converter);
}
static ImportedComponentAttribute()
{
fsSerializer.AddConverter(new AssetConverter());
}
public static BlueprintData Import(string input, out HashSet <int> incompatibleIds)
{
string unzipped;
var name = "";
incompatibleIds = new HashSet <int>();
try
{
List <string> segments = input.Split(':').ToList();
var base64Data = segments.Last();
if (segments.Count > 1)
{
segments.RemoveAt(segments.Count - 1);
name = String.Join(":", segments.ToArray());
}
unzipped = Unzip(Convert.FromBase64String(base64Data));
}
catch (Exception e)
{
Console.WriteLine("Error while unzipping string: " + e.ToString());
return(null);
}
BlueprintData deserialized = null;
try
{
fsSerializer serializer = new fsSerializer();
fsData data = fsJsonParser.Parse(unzipped);
if (data.AsDictionary.ContainsKey("version"))
{
int intVer = (int)data.AsDictionary["version"].AsInt64;
data.AsDictionary["$version"] = new fsData(intVer.ToString());
}
string version = data.AsDictionary["$version"].AsString;
if (version.Equals("1"))
{
serializer.AddConverter(new Vector3Converter_V1());
}
else
{
serializer.AddConverter(new Vector3Converter());
serializer.AddConverter(new Vector2Converter());
serializer.AddConverter(new QuaternionConverter());
}
serializer.TryDeserialize <BlueprintData>(data, ref deserialized).AssertSuccessWithoutWarnings();
}
catch (Exception e)
{
Console.WriteLine("Error while trying to deserialise: " + e.ToString());
return(null);
}
foreach (var building in deserialized.copiedBuildings)
{
building.itemProto = LDB.items.Select((int)building.protoId);
if (building.itemProto == null)
{
incompatibleIds.Add(building.protoId);
}
}
foreach (var belt in deserialized.copiedBelts)
{
belt.itemProto = LDB.items.Select((int)belt.protoId);
if (belt.itemProto == null)
{
incompatibleIds.Add(belt.protoId);
}
}
foreach (var inserter in deserialized.copiedInserters)
{
inserter.itemProto = LDB.items.Select((int)inserter.protoId);
if (inserter.itemProto == null)
{
incompatibleIds.Add(inserter.protoId);
}
}
if (incompatibleIds.Count > 0)
{
return(null);
}
deserialized.name = name;
return(deserialized);
}
