public void DeserializeGameObject(SerializableGameObject serializableObject, Transform parent)
{
GameObject myObject = Instantiate(new GameObject(), Vector3.zero, Quaternion.identity, parent);
myObject.name = serializableObject.name;
foreach (SerializableComponent sComp in serializableObject.serializableComponents)
{
Type compType = sComp.componentType as Type;
myObject.AddComponent(compType);
for (int i = 0; i < sComp.propertiesNames.Count; i++)
{
try {
string pName = sComp.propertiesNames[i];
object loadPropertyValue = sComp.values[i];
var pValue = loadPropertyValue;
if (loadPropertyValue.GetType() == typeof(SerializableVector2))
{
SerializableVector2 vector = (SerializableVector2)loadPropertyValue;
pValue = new Vector2(vector.x, vector.y);
}
else if (loadPropertyValue.GetType() == typeof(SerializableVector3))
{
SerializableVector3 vector = (SerializableVector3)loadPropertyValue;
pValue = new Vector3(vector.x, vector.y, vector.z);
}
else if (loadPropertyValue.GetType() == typeof(SerializableQuaternion))
{
SerializableQuaternion quat = (SerializableQuaternion)loadPropertyValue;
pValue = new Quaternion(quat.x, quat.y, quat.z, quat.w);
}
else if (loadPropertyValue.GetType() == typeof(SerializableSprite))
{
SerializableSprite sSprite = (SerializableSprite)loadPropertyValue;
foreach (Sprite sprite in allSprites)
{
myObject.GetComponent <SpriteRenderer>().sortingOrder = 31;
if (sprite.name.Equals(sSprite.spriteName))
{
myObject.GetComponent <SpriteRenderer>().sprite = sprite;
continue;
}
}
}
else if (loadPropertyValue.GetType() == typeof(SerializableColor))
{
SerializableColor sColor = (SerializableColor)loadPropertyValue;
pValue = new Color(sColor.r, sColor.g, sColor.b, sColor.a);
}
else if (loadPropertyValue.GetType() == typeof(SerializableVector4))
{
SerializableVector4 sVector = (SerializableVector4)loadPropertyValue;
pValue = new Vector4(sVector.x, sVector.y, sVector.z, sVector.w);
}
else if (loadPropertyValue.GetType() == typeof(SerializableBounds))
{
SerializableBounds sBounds = (SerializableBounds)loadPropertyValue;
pValue = new Bounds(new Vector3(sBounds.center[0], sBounds.center[1], sBounds.center[2])
, new Vector3(sBounds.size[0], sBounds.size[1], sBounds.size[2]));
}
else if (loadPropertyValue.GetType() == typeof(Serializable4x4Matrix))
{
Serializable4x4Matrix sMatrix = (Serializable4x4Matrix)loadPropertyValue;
Matrix4x4 matrix = new Matrix4x4();
//setting up the matrix values
matrix[0, 0] = sMatrix.data[0, 0];
matrix[0, 1] = sMatrix.data[0, 1];
matrix[0, 2] = sMatrix.data[0, 2];
matrix[0, 3] = sMatrix.data[0, 3];
matrix[1, 0] = sMatrix.data[1, 0];
matrix[1, 1] = sMatrix.data[1, 1];
matrix[1, 2] = sMatrix.data[1, 2];
matrix[1, 3] = sMatrix.data[1, 3];
matrix[2, 0] = sMatrix.data[2, 0];
matrix[2, 1] = sMatrix.data[2, 1];
matrix[2, 2] = sMatrix.data[2, 2];
matrix[2, 3] = sMatrix.data[2, 3];
matrix[3, 0] = sMatrix.data[3, 0];
matrix[3, 1] = sMatrix.data[3, 1];
matrix[3, 2] = sMatrix.data[3, 2];
matrix[3, 3] = sMatrix.data[3, 3];
pValue = matrix;
}
else if (loadPropertyValue.GetType() == typeof(SerializableVector2[]))
{
SerializableVector2[] data = (SerializableVector2[])loadPropertyValue;
Vector2[] vectors = new Vector2[data.Length];
for (int x = 0; x < data.Length; x++)
{
SerializableVector2 sVector = data[x];
vectors[x] = new Vector2(sVector.x, sVector.y);
}
pValue = vectors;
}
else if (loadPropertyValue.GetType() == typeof(SerializableVector3[]))
{
SerializableVector3[] data = (SerializableVector3[])loadPropertyValue;
Vector3[] vectors = new Vector3[data.Length];
for (int x = 0; x < data.Length; x++)
{
SerializableVector3 sVector = data[x];
vectors[x] = new Vector3(sVector.x, sVector.y);
}
pValue = vectors;
}
else if (loadPropertyValue.GetType() == typeof(SerializableAnimatorController))
{
SerializableAnimatorController sControlller = (SerializableAnimatorController)loadPropertyValue;
foreach (RuntimeAnimatorController controller in allControllers)
{
if (controller.name.Equals(sControlller.animatorControllerName))
{
myObject.GetComponent <Animator>().runtimeAnimatorController = controller;
continue;
}
}
}
PropertyInfo pInfo = compType.GetProperty(pName);
pInfo.SetValue(myObject.GetComponent(compType), pValue);
} catch (Exception e) {
Debug.LogWarning(e);
}
}
}
Vector3 position = new Vector3();
position.x = serializableObject.transformData[0][0];
position.y = serializableObject.transformData[0][1];
position.z = serializableObject.transformData[0][2];
Vector3 rotation = new Vector3();
rotation.x = serializableObject.transformData[1][0];
rotation.y = serializableObject.transformData[1][1];
rotation.z = serializableObject.transformData[1][2];
Vector3 scale = new Vector3();
scale.x = serializableObject.transformData[2][0];
scale.y = serializableObject.transformData[2][1];
scale.z = serializableObject.transformData[2][2];
myObject.transform.position = position;
myObject.transform.eulerAngles = rotation;
myObject.transform.localScale = scale;
foreach (SerializableGameObject child in serializableObject.childs)
{
DeserializeGameObject(child, myObject.transform);
}
}
public SerializableGameObject ToSerializableGameObject(GameObject targetObject)
{
Component[] allComponents;
allComponents = targetObject.GetComponents(typeof(Component));
List <SerializableComponent> serializableComponents = new List <SerializableComponent>();
foreach (Component comp in allComponents)
{
if (comp.GetType() == typeof(Transform))
{
continue;
}
SerializableComponent sComp = new SerializableComponent(comp.GetType(), null, null);
List <string> propertiesNames = new List <string>();
List <object> values = new List <object>();
foreach (PropertyInfo pInfo in comp.GetType().GetProperties())
{
try {
//trying to store the component property data
object pValue = pInfo.GetValue(targetObject.GetComponent(comp.GetType()));
if (pValue.GetType() == typeof(Vector2))
{
pValue = new SerializableVector2((Vector2)pValue);
}
else if (pValue.GetType() == typeof(Vector3))
{
pValue = new SerializableVector3((Vector3)pValue);
}
else if (pValue.GetType() == typeof(Quaternion))
{
pValue = new SerializableQuaternion((Quaternion)pValue);
}
else if (pValue.GetType() == typeof(Sprite))
{
pValue = new SerializableSprite((Sprite)pValue);
}
else if (pValue.GetType() == typeof(Color))
{
pValue = new SerializableColor((Color)pValue);
}
else if (pValue.GetType() == typeof(Vector4))
{
pValue = new SerializableVector4((Vector4)pValue);
}
else if (pValue.GetType() == typeof(Bounds))
{
pValue = new SerializableBounds((Bounds)pValue);
}
else if (pValue.GetType() == typeof(Matrix4x4))
{
pValue = new Serializable4x4Matrix((Matrix4x4)pValue);
}
else if (pValue.GetType() == typeof(Vector2[]))
{
Vector2[] data = (Vector2[])pValue;
SerializableVector2[] vectors = new SerializableVector2[data.Length];
for (int i = 0; i < data.Length; i++)
{
vectors[i] = new SerializableVector2(data[i]);
}
pValue = vectors;
}
else if (pValue.GetType() == typeof(Vector3[]))
{
Vector3[] data = (Vector3[])pValue;
SerializableVector3[] vectors = new SerializableVector3[data.Length];
for (int i = 0; i < data.Length; i++)
{
vectors[i] = new SerializableVector3(data[i]);
}
pValue = vectors;
}
else if (pValue.GetType() == typeof(RuntimeAnimatorController))
{
pValue = new SerializableAnimatorController((RuntimeAnimatorController)pValue);
}
else if (!(pValue.GetType().IsSerializable) || !(pValue.GetType().IsArray&& pValue.GetType().GetElementType().IsSerializable))
{
continue;
}
values.Add(pValue);
propertiesNames.Add(pInfo.Name);
} catch (Exception e) {
continue;
}
}
sComp.propertiesNames = propertiesNames;
foreach (object obj in values)
{
if (obj.GetType().IsSerializable == false)
{
values.Remove(obj);
propertiesNames.Remove(propertiesNames[values.IndexOf(obj)]);
}
Debug.Log(".............." + obj.GetType() + "..............");
}
sComp.values = values;
serializableComponents.Add(sComp);
}
List <SerializableGameObject> childs = new List <SerializableGameObject>();
foreach (Transform child in targetObject.transform)
{
childs.Add(ToSerializableGameObject(child.gameObject));
}
List <float> position = new List <float>();
position.Add(targetObject.transform.position.x);
position.Add(targetObject.transform.position.y);
position.Add(targetObject.transform.position.z);
List <float> rotation = new List <float>();
rotation.Add(targetObject.transform.eulerAngles.x);
rotation.Add(targetObject.transform.eulerAngles.y);
rotation.Add(targetObject.transform.eulerAngles.z);
List <float> scale = new List <float>();
scale.Add(targetObject.transform.localScale.x);
scale.Add(targetObject.transform.localScale.y);
scale.Add(targetObject.transform.localScale.z);
List <List <float> > transformData = new List <List <float> >();
transformData.Add(position);
transformData.Add(rotation);
transformData.Add(scale);
SerializableGameObject sObject = new SerializableGameObject(targetObject.name, serializableComponents, transformData, childs);
return(sObject);
}
public void Generate(EnemyType p_type)
{
GameObject enemyObject = Instantiate(m_enemyTemplate);
SpriteRenderer renderer = enemyObject.GetComponent <SpriteRenderer>();
StateController controller = enemyObject.GetComponent <StateController>();
Enemy enemy = enemyObject.GetComponent <Enemy>();
EnemyType type = p_type;
List <SerializableSprite> sprites = new List <SerializableSprite>();
List <int> minStats = new List <int>(type.m_minimumStats);
List <int> maxStats = new List <int>(type.m_maximumStats);
bool male = Random.Range(0, 100) >= 50;
if (m_useExternalTypes)
{
type = m_combinedTypes.Find(et => et.m_type == p_type.m_type);
}
if (male)
{
if (type.m_maleSprites.Count > 0)
{
sprites.AddRange(type.m_maleSprites);
}
}
else
{
if (type.m_femaleSprites.Count > 0)
{
sprites.AddRange(type.m_femaleSprites);
}
}
enemy.Init();
enemyObject.name = type.m_type;
SerializableSprite sprite = sprites[Random.Range(0, sprites.Count)];
sprite.m_name = (male ? "Male/" : "Female/") + sprite.m_name;
renderer.sprite = sprite.Sprite;
enemy.m_dialog.m_dialogTemplate = GameObject.Find("UI").transform.Find("Dialogue Canvas").Find("Speech Bubble").gameObject;
enemy.m_dialog.m_currentDialog = Dialog.Get(type.m_greetings[Random.Range(0, type.m_greetings.Count)]);
enemy.m_dialog.Init();
enemy.transform.position = Player.GetPlayerFromId(0).transform.position;
enemy.m_entity.m_feedbackTemplate = GameObject.Find("UI").transform.Find("Feedback Canvas").Find("Feedback").gameObject;
if (type.m_defaultStates.Count > 0 && type.m_looks.Count > 0)
{
enemy.m_entity.m_look = type.m_looks[Random.Range(0, type.m_looks.Count)];
controller.m_enemyEntitiesSets.Add("players");
controller.m_enemyEntitiesSets.Add("npcs");
controller.m_currentState = State.Get(type.m_defaultStates[Random.Range(0, type.m_defaultStates.Count)]);
controller.Setup();
}
StartCoroutine(SetStats(enemy, minStats, maxStats));
}
public void Generate(List <NPCType> p_specificTypes)
{
GameObject npcObject = Instantiate(m_npcTemplate);
SpriteRenderer renderer = npcObject.GetComponent <SpriteRenderer>();
StateController controller = npcObject.GetComponent <StateController>();
NPC npc = npcObject.GetComponent <NPC>();
List <NPCType> allTypes = new List <NPCType>();
List <string> possibleGreetings = new List <string>();
List <string> quests = new List <string>();
List <string> names = new List <string>();
List <SerializableSprite> sprites = new List <SerializableSprite>();
List <int> minStats = new List <int>();
List <int> maxStats = new List <int>();
List <string> states = new List <string>();
List <Look> looks = new List <Look>();
bool male = Random.Range(0, 100) >= 50;
bool priorityTypeProcessed = false;
foreach (NPCType specific in p_specificTypes)
{
NPCType type = specific;
if (m_useExternalTypes)
{
type = m_combinedTypes.Find(nt => nt.m_type == specific.m_type);
}
allTypes.Add(type);
if (type.m_priorityType && !priorityTypeProcessed)
{
names.Clear();
sprites.Clear();
priorityTypeProcessed = true;
}
if (type.m_priorityType || !priorityTypeProcessed)
{
if (male)
{
if (type.m_maleNames.Count > 0)
{
names.AddRange(type.m_maleNames);
}
if (type.m_maleSprites.Count > 0)
{
sprites.AddRange(type.m_maleSprites);
}
}
else
{
if (type.m_femaleNames.Count > 0)
{
names.AddRange(type.m_femaleNames);
}
if (type.m_femaleSprites.Count > 0)
{
sprites.AddRange(type.m_femaleSprites);
}
}
if (type.m_minimumStats != null && type.m_minimumStats.Count > 0 &&
type.m_maximumStats != null && type.m_maximumStats.Count > 0)
{
minStats = type.m_minimumStats;
maxStats = type.m_maximumStats;
}
if (type.m_defaultStates.Count > 0)
{
states.AddRange(type.m_defaultStates);
}
if (type.m_looks.Count > 0)
{
looks.AddRange(type.m_looks);
}
}
if (type.m_greetings.Count > 0)
{
possibleGreetings.AddRange(type.m_greetings);
}
if (type.m_quests.Count > 0)
{
int questCount = 0;
float random = Random.Range(0f, 100f);
while (random <= type.m_questPercentage && (questCount <= type.m_quests.Count || questCount <= 3))
{
questCount++;
random = Random.Range(0f, 100f);
}
if (questCount > 0)
{
List <string> availableQuests = new List <string>(type.m_quests);
for (int i = 0; i < questCount; i++)
{
if (availableQuests.Count == 0)
{
break;
}
string sQuest = availableQuests[Random.Range(0, availableQuests.Count)];
List <string> currentQuests = new List <string>(quests);
List <string> topLevelQuests = new List <string>();
GetTopLevelQuests(sQuest, ref currentQuests, ref topLevelQuests);
foreach (string top in topLevelQuests)
{
if (availableQuests.Contains(top))
{
availableQuests.Remove(top);
quests.Add(top);
}
}
i += topLevelQuests.Count;
}
}
}
}
npc.Init(allTypes, "npcs");
npcObject.name = names[Random.Range(0, names.Count)];
SerializableSprite sprite = sprites[Random.Range(0, sprites.Count)];
sprite.m_name = (male ? "Male/" : "Female/") + sprite.m_name;
renderer.sprite = sprite.Sprite;
npc.m_questsAvailable = quests;
npc.m_dialog.m_dialogTemplate = GameObject.Find("UI").transform.Find("Dialogue Canvas").Find("Speech Bubble").gameObject;
npc.m_dialog.m_currentDialog = Dialog.Get(possibleGreetings[Random.Range(0, possibleGreetings.Count)]);
npc.m_dialog.Init();
npc.transform.position = Player.GetPlayerFromId(0).transform.position;
npc.m_entity.m_feedbackTemplate = GameObject.Find("UI").transform.Find("Feedback Canvas").Find("Feedback").gameObject;
if (states.Count > 0 && looks.Count > 0)
{
npc.m_entity.m_look = looks[Random.Range(0, looks.Count)];
controller.m_enemyEntitiesSets.Add("enemies");
controller.m_currentState = State.Get(states[Random.Range(0, states.Count)]);
controller.Setup();
}
StartCoroutine(SetStats(npc, minStats, maxStats));
}
