/// <summary>
/// Read the data into the specified value.
/// </summary>
/// <param name="value">Value.</param>
/// <param name="reader">Reader.</param>
public override void ReadInto(object value, ISaveGameReader reader)
{
UnityEngine.FlareLayer flareLayer = (UnityEngine.FlareLayer)value;
foreach (string property in reader.Properties)
{
switch (property)
{
case "enabled":
flareLayer.enabled = reader.ReadProperty <System.Boolean> ();
break;
case "tag":
flareLayer.tag = reader.ReadProperty <System.String> ();
break;
case "name":
flareLayer.name = reader.ReadProperty <System.String> ();
break;
case "hideFlags":
flareLayer.hideFlags = reader.ReadProperty <UnityEngine.HideFlags> ();
break;
}
}
}
/// <summary>
/// Write the specified value using the writer.
/// </summary>
/// <param name="value">Value.</param>
/// <param name="writer">Writer.</param>
public override void Write(object value, ISaveGameWriter writer)
{
UnityEngine.FlareLayer flareLayer = (UnityEngine.FlareLayer)value;
writer.WriteProperty("enabled", flareLayer.enabled);
writer.WriteProperty("tag", flareLayer.tag);
writer.WriteProperty("name", flareLayer.name);
writer.WriteProperty("hideFlags", flareLayer.hideFlags);
}
void Awake()
{
finale = FindObjectOfType<FinaleController>();
playerFX = transform.Find("PlayerPedestal/Player/PlayerCamera").GetComponent<PostProcessing>();
playerFlare = transform.Find("PlayerPedestal/Player/PlayerCamera").GetComponent<FlareLayer>();
destroyables = FindObjectsOfType<PortalDestroy>();
stateAudio = transform.Find("GameAudio/StateAudio").GetComponents<AudioSource>();
pauseMenu = transform.Find("GameUI/PauseMenu").GetComponent<PauseMenu>();
if (GAME_COMPLETE && FindObjectOfType<LivingRoomController>() != null)
canPause = false;
}
/// <summary>
/// Read the data using the reader.
/// </summary>
/// <param name="reader">Reader.</param>
public override object Read(ISaveGameReader reader)
{
UnityEngine.FlareLayer flareLayer = SaveGameType.CreateComponent <UnityEngine.FlareLayer> ();
ReadInto(flareLayer, reader);
return(flareLayer);
}
public static void componentSerialize(string ser)
{
GameObject gameObject = null;
MarkerFlag objMarker = deserializeMarkerFlag(ref ser);
int hashLoc = genHashCode(objMarker.id);
int xLoc = hashLoc % 10;
int yLoc = hashLoc % 100;
MarkerFlag thisFlag = findInList(objMarker.id, xLoc, yLoc);
if (thisFlag == null) //Make a new game object with given flag if you need to
{
gameObject = new GameObject();
thisFlag = gameObject.AddComponent <MarkerFlag>();
}
else
{
gameObject = thisFlag.gameObject;
}
thisFlag.id = objMarker.id;
thisFlag.parentID = objMarker.parentID;
thisFlag.isLocked = objMarker.isLocked;
if (thisFlag.parentID != "_")
{
int parentHash = genHashCode(thisFlag.parentID);
int xParent = parentHash % 10;
int yParent = parentHash % 100;
MarkerFlag parentFlag = findInList(thisFlag.parentID, xParent, yParent);
if (parentFlag != null)
{
gameObject.transform.SetParent(parentFlag.gameObject.transform);
}
else
{
gameObject.transform.SetParent(null);
}
}
else
{
gameObject.transform.SetParent(null);
}
gameObject.name = deserializeString(ref ser);
gameObject.tag = deserializeString(ref ser);
gameObject.layer = deserializeInt(ref ser);
gameObject.isStatic = deserializeBool(ref ser);
while (ser.Length > 0)
{
string tag = deserializeString(ref ser); //Identifies the component type
if (tag == "transform")
{
UnityEngine.Transform trans = gameObject.transform;
trans.position = deserializeVector3(ref ser);
trans.rotation = deserializeQuaternion(ref ser);
trans.localScale = deserializeVector3(ref ser);
if (expectedObjs > -1)
{
thisFlag.ogPos = trans.position;
thisFlag.ogRot = trans.rotation;
thisFlag.ogScale = trans.localScale;
}
}
else if (tag == "boxCollider")
{
UnityEngine.BoxCollider col = gameObject.GetComponent <UnityEngine.BoxCollider>();
if (col == null)
{
col = gameObject.AddComponent <UnityEngine.BoxCollider>();
}
col.center = deserializeVector3(ref ser);
col.size = deserializeVector3(ref ser);
col.isTrigger = deserializeBool(ref ser);
}
else if (tag == "sphereCollider")
{
UnityEngine.SphereCollider col = gameObject.GetComponent <UnityEngine.SphereCollider>();
if (col == null)
{
col = gameObject.AddComponent <UnityEngine.SphereCollider>();
}
col.center = deserializeVector3(ref ser);
col.radius = deserializeFloat(ref ser);
col.isTrigger = deserializeBool(ref ser);
}
else if (tag == "capsuleCollider")
{
UnityEngine.CapsuleCollider col = gameObject.GetComponent <UnityEngine.CapsuleCollider>();
if (col == null)
{
col = gameObject.AddComponent <UnityEngine.CapsuleCollider>();
}
col.center = deserializeVector3(ref ser);
col.radius = deserializeFloat(ref ser);
col.height = deserializeFloat(ref ser);
col.direction = deserializeInt(ref ser);
col.isTrigger = deserializeBool(ref ser);
}
else if (tag == "rigidbody")
{
UnityEngine.Rigidbody col = gameObject.GetComponent <UnityEngine.Rigidbody>();
if (col == null)
{
col = gameObject.AddComponent <UnityEngine.Rigidbody>();
}
col.mass = deserializeFloat(ref ser);
col.drag = deserializeFloat(ref ser);
col.angularDrag = deserializeFloat(ref ser);
col.interpolation = (RigidbodyInterpolation)deserializeInt(ref ser);
col.constraints = (RigidbodyConstraints)deserializeInt(ref ser);
col.useGravity = deserializeBool(ref ser);
col.isKinematic = deserializeBool(ref ser);
col.detectCollisions = deserializeBool(ref ser);
}
else if (tag == "camera")
{
UnityEngine.Camera cam = gameObject.GetComponent <UnityEngine.Camera>();
if (cam == null)
{
cam = gameObject.AddComponent <UnityEngine.Camera>();
}
cam.clearFlags = (CameraClearFlags)deserializeInt(ref ser);
cam.backgroundColor = deserializeColor(ref ser);
cam.cullingMask = deserializeInt(ref ser);
cam.nearClipPlane = deserializeFloat(ref ser);
cam.farClipPlane = deserializeFloat(ref ser);
cam.rect = deserializeRect(ref ser);
cam.renderingPath = (RenderingPath)deserializeInt(ref ser);
cam.allowHDR = deserializeBool(ref ser);
cam.allowMSAA = deserializeBool(ref ser);
cam.useOcclusionCulling = deserializeBool(ref ser);
cam.depth = deserializeFloat(ref ser);
cam.fieldOfView = deserializeFloat(ref ser);
cam.targetDisplay = deserializeInt(ref ser);
}
else if (tag == "light")
{
UnityEngine.Light li = gameObject.GetComponent <UnityEngine.Light>();
if (li == null)
{
li = gameObject.AddComponent <UnityEngine.Light>();
}
li.type = (LightType)deserializeInt(ref ser);
li.shadows = (LightShadows)deserializeInt(ref ser);
li.renderMode = (LightRenderMode)deserializeInt(ref ser);
li.cullingMask = deserializeInt(ref ser);
li.color = deserializeColor(ref ser);
li.intensity = deserializeFloat(ref ser);
li.cookieSize = deserializeFloat(ref ser);
}
else if (tag == "meshfilter")
{
UnityEngine.MeshFilter meshFilter = gameObject.GetComponent <UnityEngine.MeshFilter>();
if (meshFilter == null)
{
meshFilter = gameObject.AddComponent <UnityEngine.MeshFilter>();
}
string filePath = deserializeString(ref ser);
string meshName = deserializeString(ref ser);
UnityEngine.Object[] assets = AssetDatabase.LoadAllAssetsAtPath(filePath);
for (int x = 0; x < assets.Length; ++x)
{
if (assets[x].name == meshName)
{
gameObject.GetComponent <UnityEngine.MeshFilter>().mesh = assets[x] as UnityEngine.Mesh;
break;
}
}
}
else if (tag == "meshRenderer")
{
UnityEngine.MeshRenderer gOMeshRenderer = gameObject.GetComponent <UnityEngine.MeshRenderer>();
if (gOMeshRenderer == null)
{
gOMeshRenderer = gameObject.AddComponent <UnityEngine.MeshRenderer>();
}
gOMeshRenderer.lightProbeUsage = (UnityEngine.Rendering.LightProbeUsage)deserializeInt(ref ser);
gOMeshRenderer.reflectionProbeUsage = (UnityEngine.Rendering.ReflectionProbeUsage)deserializeInt(ref ser);
gOMeshRenderer.shadowCastingMode = (UnityEngine.Rendering.ShadowCastingMode)deserializeInt(ref ser);
gOMeshRenderer.receiveShadows = deserializeBool(ref ser);
gOMeshRenderer.motionVectorGenerationMode = (UnityEngine.MotionVectorGenerationMode)deserializeInt(ref ser);
//Light map static junk
deserializeBool(ref ser);
string materialsList = deserializeString(ref ser);
List <Material> renderMaterials = new List <Material>();
if (materialsList.Length > 1)
{
while (materialsList != "")
{
int length = materialsList.IndexOf(",");
if (length > 0)
{
string ret = materialsList.Substring(0, length);
materialsList = materialsList.Remove(0, length + 1);
Material newMat = null;
if (ret == "Default-Material" || ret == "" || ret == "Resources/unity_builtin_extra")
{
newMat = AssetDatabase.GetBuiltinExtraResource <Material>("Default-Diffuse.mat");
}
else
{
newMat = (Material)AssetDatabase.LoadAssetAtPath(ret, typeof(Material));
}
renderMaterials.Add(newMat);
}
}
if (renderMaterials.Count > 0)
{
gOMeshRenderer.GetComponent <Renderer>().materials = renderMaterials.ToArray();
}
}
}
else if (tag == "guilayer")
{
UnityEngine.GUILayer gOGuiLayer = gameObject.GetComponent <GUILayer>();
if (gOGuiLayer == null)
{
gOGuiLayer = gameObject.AddComponent <GUILayer>();
}
}
else if (tag == "flarelayer")
{
UnityEngine.FlareLayer gOFlareLayer = gameObject.GetComponent <FlareLayer>();
if (gOFlareLayer == null)
{
gOFlareLayer = gameObject.AddComponent <FlareLayer>();
}
}
else if (tag == "audiolistener")
{
UnityEngine.AudioListener gOAudioListener = gameObject.GetComponent <AudioListener>();
if (gOAudioListener == null)
{
gOAudioListener = gameObject.AddComponent <AudioListener>();
}
}
else
{
Debug.Log("Unkown Componenet Type " + tag);
}
}
addToMap(thisFlag);
}
public static string serialize(GameObject obj)
{
string serialized = ""; //Message.GO_UPDATE.ToString();
serMarkerFlag serMarker = new serMarkerFlag(); //Put the marker flag info on the string first !!!
serMarker.flag = obj.GetComponent <MarkerFlag>();
if (obj.transform.parent == null)
{
serMarker.flag.parentID = "__";
}
else
{
serMarker.flag.parentID = obj.transform.parent.GetComponent <MarkerFlag>().id;
}
string flagData = new string(serMarker.toChar());
serialized += flagData;
int hashLoc = genHashCode(serMarker.flag.id);
int xLoc = hashLoc % 10;
int yLoc = hashLoc % 100;
//TODO check location if it already is there
objectMap[xLoc, yLoc].Add(serMarker.flag);
serialized += obj.name + "|";
serialized += obj.tag + "|";
serialized += obj.layer + "|";
serialized += obj.isStatic + "|";
Component[] comps;
comps = obj.GetComponents <Component>();
for (int i = 0; i < comps.Length; i++)
{
if (comps[i] != null)
{
if (comps[i].GetType() == typeof(UnityEngine.Transform))
{
UnityEngine.Transform newTransform = comps[i] as UnityEngine.Transform;
Transform serNewTransform = new Transform();
serNewTransform.pos = newTransform.position;
serNewTransform.rot = newTransform.rotation;
serNewTransform.scale = newTransform.localScale;
string transformString = new string(serNewTransform.toChar());
serialized += transformString;
}
else if (comps[i].GetType() == typeof(UnityEngine.BoxCollider))
{
UnityEngine.BoxCollider newBoxCollider = comps[i] as UnityEngine.BoxCollider;
BoxCollider serNewBoxCollider = new BoxCollider();
serNewBoxCollider.center = newBoxCollider.center;
serNewBoxCollider.size = newBoxCollider.size;
serNewBoxCollider.isTrigger = newBoxCollider.isTrigger;
string boxColliderString = new string(serNewBoxCollider.toChar());
serialized += boxColliderString;
}
else if (comps[i].GetType() == typeof(UnityEngine.SphereCollider))
{
UnityEngine.SphereCollider newSphereCollider = comps[i] as UnityEngine.SphereCollider;
SphereCollider serNewSphereCollider = new SphereCollider();
serNewSphereCollider.center = newSphereCollider.center;
serNewSphereCollider.radius = newSphereCollider.radius;
serNewSphereCollider.isTrigger = newSphereCollider.isTrigger;
string sphereColliderString = new string(serNewSphereCollider.toChar());
serialized += sphereColliderString;
}
else if (comps[i].GetType() == typeof(UnityEngine.CapsuleCollider))
{
UnityEngine.CapsuleCollider newCapsuleCollider = comps[i] as UnityEngine.CapsuleCollider;
CapsuleCollider serNewCapsuleCollider = new CapsuleCollider();
serNewCapsuleCollider.center = newCapsuleCollider.center;
serNewCapsuleCollider.radius = newCapsuleCollider.radius;
serNewCapsuleCollider.height = newCapsuleCollider.height;
serNewCapsuleCollider.directionAxis = newCapsuleCollider.direction;
serNewCapsuleCollider.isTrigger = newCapsuleCollider.isTrigger;
string capsuleColliderString = new string(serNewCapsuleCollider.toChar());
serialized += capsuleColliderString;
}
else if (comps[i].GetType() == typeof(UnityEngine.Rigidbody))
{
UnityEngine.Rigidbody newRigidBody = comps[i] as UnityEngine.Rigidbody;
RigidBody serNewRigidBody = new RigidBody();
serNewRigidBody.mass = newRigidBody.mass;
serNewRigidBody.drag = newRigidBody.drag;
serNewRigidBody.angularDrag = newRigidBody.angularDrag;
serNewRigidBody.interpolate = (int)newRigidBody.interpolation;
serNewRigidBody.collisionDetection = newRigidBody.detectCollisions;
serNewRigidBody.freeze = (int)newRigidBody.constraints;
serNewRigidBody.isKinematic = newRigidBody.isKinematic;
serNewRigidBody.useGravity = newRigidBody.useGravity;
serNewRigidBody.collisionDetection = newRigidBody.detectCollisions;
string rigidBodyString = new string(serNewRigidBody.toChar());
serialized += rigidBodyString;
}
else if (comps[i].GetType() == typeof(UnityEngine.Camera))
{
UnityEngine.Camera newCamera = comps[i] as UnityEngine.Camera;
Camera serNewCamera = new Camera();
serNewCamera.clearFlags = (int)newCamera.clearFlags;
serNewCamera.background = newCamera.backgroundColor;
serNewCamera.cullingMask = newCamera.cullingMask;
serNewCamera.projection = newCamera.projectionMatrix.ToString();
serNewCamera.near = newCamera.nearClipPlane;
serNewCamera.far = newCamera.farClipPlane;
serNewCamera.viewportRect = newCamera.rect;
serNewCamera.renderingPath = (int)newCamera.renderingPath;
serNewCamera.HDR = newCamera.allowHDR;
serNewCamera.MSAA = newCamera.allowMSAA;
serNewCamera.occlusionCulling = newCamera.useOcclusionCulling;
serNewCamera.depth = newCamera.depth;
serNewCamera.fov = newCamera.fieldOfView;
serNewCamera.targetDisplay = newCamera.targetDisplay;
string cameraString = new string(serNewCamera.toChar());
serialized += cameraString;
}
else if (comps[i].GetType() == typeof(UnityEngine.MeshFilter))
{
//Gather Meshfilter information on current GO
UnityEngine.MeshFilter gOMeshFilter = comps[i] as UnityEngine.MeshFilter;
Mesh gOMesh = gOMeshFilter.sharedMesh;
//Pack data into our meshfilter object
MeshFilter meshStruct = new MeshFilter();
meshStruct.filePath = AssetDatabase.GetAssetPath(gOMesh);
meshStruct.meshName = gOMesh.name;
//Convert the data into a string and add it to the overall data stream
string sStream = new string(meshStruct.toChar());
serialized += sStream;
}
else if (comps[i].GetType() == typeof(UnityEngine.MeshRenderer))
{
UnityEngine.MeshRenderer gOMeshRenderer = comps[i] as UnityEngine.MeshRenderer;
//Pack data into our MeshRenderer obj
MeshRenderer meshStruct = new MeshRenderer();
meshStruct.lightProbe = (int)gOMeshRenderer.lightProbeUsage;
meshStruct.reflectionProbe = (int)gOMeshRenderer.reflectionProbeUsage;
meshStruct.castShadows = (int)gOMeshRenderer.shadowCastingMode;
meshStruct.receiveShadows = gOMeshRenderer.receiveShadows;
meshStruct.motionVectors = (int)gOMeshRenderer.motionVectorGenerationMode;
meshStruct.lightmapStatic = false;
Material[] gOMaterials = gOMeshRenderer.sharedMaterials;
for (int q = 0; q < gOMaterials.Length; ++q)
{
string materialPath = "";
if (gOMaterials[q] == null || gOMaterials[q].name == "Default-Material")
{
materialPath = "Default-Material";
}
else
{
materialPath = AssetDatabase.GetAssetPath(gOMaterials[q]);
}
meshStruct.materialFiles.Add(materialPath);
}
string sStream = new string(meshStruct.toChar());
serialized += sStream;
}
else if (comps[i].GetType() == typeof(UnityEngine.Light))
{
UnityEngine.Light newLight = comps[i] as UnityEngine.Light;
Light serNewLight = new Light();
serNewLight.type = (int)newLight.type;
serNewLight.shadows = (int)newLight.shadows;
serNewLight.mode = (int)newLight.renderMode;
serNewLight.cullingMask = newLight.cullingMask;
serNewLight.color = newLight.color;
serNewLight.intensity = newLight.intensity;
serNewLight.cookie = newLight.cookieSize;
string lightString = new string(serNewLight.toChar());
serialized += lightString;
}
else if (comps[i].GetType() == typeof(UnityEngine.GUILayer))
{
UnityEngine.GUILayer newGuiLayer = comps[i] as UnityEngine.GUILayer;
string lightString = "guilayer|";
serialized += lightString;
}
else if (comps[i].GetType() == typeof(UnityEngine.FlareLayer))
{
UnityEngine.FlareLayer newGuiLayer = comps[i] as UnityEngine.FlareLayer;
string lightString = "flarelayer|";
serialized += lightString;
}
else if (comps[i].GetType() == typeof(UnityEngine.AudioListener))
{
UnityEngine.AudioListener newGuiLayer = comps[i] as UnityEngine.AudioListener;
string lightString = "audiolistener|";
serialized += lightString;
}
}
}
return(serialized);
}
