public static void ReparentObjects() //Used to reparent all objects, used when server has sent over all game objects
{
GameObject[] allGameobjects = GameObject.FindObjectsOfType <GameObject>(); //Get all gameobjs
EditorUtility.DisplayProgressBar("Reparenting Objects", "", 0);
for (int i = 0; i < allGameobjects.Length; ++i)
{
MarkerFlag currentFlag = allGameobjects[i].GetComponent <MarkerFlag>();
if (currentFlag.parentID != null && currentFlag.parentID != "__")
{
int parentHash = genHashCode(currentFlag.parentID);
int xParent = parentHash % 10;
int yParent = parentHash % 100;
MarkerFlag parentFlag = findInList(currentFlag.parentID, xParent, yParent);
if (parentFlag != null)
{
allGameobjects[i].transform.SetParent(parentFlag.gameObject.transform, false); //Parent the object
allGameobjects[i].transform.position = currentFlag.ogPos; //Reapply the local values because they have changed with the parent
allGameobjects[i].transform.localScale = currentFlag.ogScale;
allGameobjects[i].transform.rotation = currentFlag.ogRot;
}
else
{
allGameobjects[i].transform.SetParent(null);
}
}
EditorUtility.DisplayProgressBar("Getting Level Data", allGameobjects[i].name, (float)i / allGameobjects.Length);
}
Lightmapping.giWorkflowMode = Lightmapping.GIWorkflowMode.Iterative;
EditorUtility.ClearProgressBar();
}
//Functions to return various types of information for interpreting the given string information
public static MarkerFlag deserializeMarkerFlag(ref string ser)
{
MarkerFlag markerFlag = new MarkerFlag();
markerFlag.id = deserializeString(ref ser);
markerFlag.parentID = deserializeString(ref ser);
markerFlag.isLocked = deserializeBool(ref ser);
return(markerFlag);
}
public static void addToMap(MarkerFlag flag)
{
int hashCode = genHashCode(flag.id);
int xLoc = hashCode % 10;
int yLoc = hashCode % 100;
if (!objectMap[xLoc, yLoc].Contains(flag)) //The flag doesn't exsist in the map anywhere
{
objectMap[xLoc, yLoc].Add(flag);
}
//Otherwise, don't bother adding it
}
static void editMode()
{
GameObject[] allGameobjects = GameObject.FindObjectsOfType <GameObject>();
List <GameObject> selectedObjects = new List <GameObject>(Selection.gameObjects);
if (selectedObjects.Count > 0)
{
List <GameObject> approvedObjects = new List <GameObject>();
for (int i = 0; i < selectedObjects.Count; ++i)
{
MarkerFlag selectedObjFlags = selectedObjects[i].GetComponent <MarkerFlag>();
if (selectedObjFlags == null) //If an object doesn't have the marker flag script on it
{
//it will be added
selectedObjFlags = selectedObjects[i].AddComponent <MarkerFlag>();
selectedObjFlags.id = objectId + objCounter.ToString();
objCounter++;
}
else
{
if (!selectedObjFlags.isLocked)
{
selectedObjFlags.isModified = true;
selectedObjFlags.isHeld = true;
approvedObjects.Add(selectedObjects[i]);
}
}
}
Selection.objects = approvedObjects.ToArray();
}
for (int i = 0; i < allGameobjects.Length; ++i)
{
MarkerFlag pMarkerFlag = allGameobjects[i].GetComponent <MarkerFlag>();
if (pMarkerFlag.isHeld) //If the object is marked as is held
{
if (!selectedObjects.Contains(allGameobjects[i])) //If the object isn't still selected
{
pMarkerFlag.isHeld = false;
UnlockObject(pMarkerFlag);
}
}
}
//If the system is running AND the sync interval is 0 or if the current time is greater than the last sync time + the sync interval
if (mConnected && (syncInterval == 0 || DateTime.Now.Minute * 60 + DateTime.Now.Second >=
(lastSyncTime.Second + syncInterval + lastSyncTime.Minute * 60)))
{
Sync(Selection.gameObjects);
lastSyncTime = DateTime.Now;
}
}
public static void startupServer(int portNum, int maxClients)
{
Serializer.init();
EditorUtility.DisplayProgressBar("Setting up", "", 0);
objectId = "Server ";
//Runs through entire scene and setups marker flags
objCounter = 0;
allGOs = GameObject.FindObjectsOfType <GameObject>(); //Get all gameobjs
for (int i = 0; i < allGOs.Length; ++i)
{
MarkerFlag objectFlag = allGOs[i].GetComponent <MarkerFlag>();
if (objectFlag == null)
{
objectFlag = allGOs[i].AddComponent <MarkerFlag>();
}
objectFlag.id = objectId + objCounter;
Serializer.addToMap(objectFlag);
objCounter++;
EditorUtility.DisplayProgressBar("Setting up", allGOs[i].name, (float)i / (allGOs.Length - 1));
}
// get server ip address
string hostName = System.Net.Dns.GetHostName();
IPHostEntry ipEntry = System.Net.Dns.GetHostEntry(hostName);
IPAddress[] addr = ipEntry.AddressList;
//int index = 0;
//foreach (IPAddress i in addr)
// index++;
//serverIP = addr[3].ToString();
//Debug.Log(serverIP);
//Calls plugin function to start server
StartServer("", portNum, maxClients);
mIsServer = true;
mConnected = true;
EditorUtility.ClearProgressBar();
ServerUtil.saveToNewScene();
if (MultiuserEditor.limitAutosave)
{
ServerUtil.checkTooManyScenes();
}
}
public static void deleteGO(string info) //Function used to delete a gameobject
{
string gOId = deserializeString(ref info);
int hashLoc = genHashCode(gOId);
int xLoc = hashLoc % 10;
int yLoc = hashLoc % 100;
MarkerFlag thisFlag = null;
thisFlag = findInList(gOId, xLoc, yLoc);
if (thisFlag != null)
{
MonoBehaviour.DestroyImmediate(thisFlag.gameObject);
}
}
public static void DeleteObject(MarkerFlag target)
{
if (mConnected)
{
string targetID = target.id + "|";
if (!mIsServer)
{
SendData((int)Serializer.Message.GO_DELETE, targetID, targetID.Length, "");
}
else
{
for (int j = 0; j < mConnectedClients.Count; ++j)
{
if (mConnectedClients[j].IP != "")
{
SendData((int)Serializer.Message.GO_DELETE, targetID, targetID.Length, mConnectedClients[j].IP);
}
}
}
}
}
public static void UnlockObject(MarkerFlag target)
{
if (mConnected)
{
string targetID = Serializer.serialize(target.gameObject);
if (!mIsServer)
{
SendData((int)Serializer.Message.GO_UPDATE, targetID, targetID.Length, "");
}
else
{
for (int j = 0; j < mConnectedClients.Count; ++j)
{
if (mConnectedClients[j].IP != "")
{
SendData((int)Serializer.Message.GO_UPDATE, targetID, targetID.Length, mConnectedClients[j].IP);
}
}
}
}
}
public static void Sync(GameObject[] gOsToSend) //Sends out the data of the "modified" objects
{
for (int i = 0; i < gOsToSend.Length; ++i) //Checks All objects in scene and
{
MarkerFlag objectFlag = gOsToSend[i].GetComponent <MarkerFlag>(); //TODO: Potentially expensive might change
if (objectFlag == null) //If an object doesn't have the marker flag script on it
{ //it will be added. This happens when a new object has been made
objectFlag = gOsToSend[i].AddComponent <MarkerFlag>();
objectFlag.name = objectId + objCounter; //Make a uniquie name for the client so that other objects can't get confused by it
objCounter++;
}
if (objectFlag.isModified) //If this object's marker flag has been modified
{
string serializedObj = Serializer.serialize(gOsToSend[i]);
if (!mIsServer)
{
SendData((int)Serializer.Message.GO_UPDATE, serializedObj, serializedObj.Length, serverIP);
}
else
{
for (int j = 0; j < mConnectedClients.Count; ++j)
{
if (mConnectedClients[j].IP != "")
{
SendData((int)Serializer.Message.GO_UPDATE, serializedObj, serializedObj.Length, mConnectedClients[j].IP);
}
}
}
objectFlag.isModified = false;
}
}
}
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);
}
