public override void DeserializeFromJson(string json)
{
base.DeserializeFromJson(json);
Dictionary <string, object> data = SerializationUtilitites.DeserializeFromJson <Dictionary <string, object> >(json);
Protection = Convert.ToInt32(data["Protection"]);
}
public void SaveGame()
{
string savedGameName = "SavedGame"; // TODO Replace this by a user provided name or the current date?
string rootPath = Path.Combine(_rootDataPath, savedGameName);
// Save the Game State
string savePath = Path.Combine(rootPath, "GameSata.json");
FileInfo saveFile = new FileInfo(savePath);
saveFile.Directory.Create();
Dictionary <string, string> data = new Dictionary <string, string>();
data["Location"] = SceneManager.GetActiveScene().name;
data["PreviousLocation"] = PreviousSceneName;
File.WriteAllText(saveFile.FullName, SerializationUtilitites.SerializeToJson(data));
Debug.Log(string.Format("Saved Game to: {0}", savePath));
// Save the Character
foreach (BaseCharacter player in CharacterSet.Items)
{
savePath = Path.Combine(Path.Combine(rootPath, "Characters"), player.Stats.Name + ".json");
saveFile = new FileInfo(savePath);
saveFile.Directory.Create();
File.WriteAllText(saveFile.FullName, SerializationUtilitites.SerializeToJson(player.SerializeToData()));
Debug.Log(string.Format("Saved {0} to: {1}", player.Stats.Name, savePath));
}
}
public void DeserializeFromData(Dictionary <string, object> data)
{
float[] position = SerializationUtilitites.DeserializeFromObject <float[]>(data["Position"]);
Position = new Vector3(position[0], position[1], position[2]);
Radius = Convert.ToInt32(data["Radius"]);
Angle = Convert.ToInt32(data["Angle"]);
}
public void DeserializeFromJson(string json)
{
Dictionary <string, object> data = JsonConvert.DeserializeObject <Dictionary <string, object> >(json);
Stats.DeserializeFromData(SerializationUtilitites.DeserializeFromObject <Dictionary <string, object> >(data["Stats"]));
Inventory.DeserializeFromData(SerializationUtilitites.DeserializeFromObject <Dictionary <string, object> >(data["Inventory"]));
float[] transformData = JsonConvert.DeserializeObject <float[]>(JsonConvert.SerializeObject(data["Transform"]));
transform.position = new Vector3(transformData[0], transformData[1], transformData[2]);
}
public void SerializePlayer()
{
PlayerA.transform.position = new Vector3(1, 2, 3);
string jsonPlayerA = SerializationUtilitites.SerializeToJson(PlayerA.SerializeToData());
PlayerB.DeserializeFromJson(jsonPlayerA);
string jsonPlayerB = SerializationUtilitites.SerializeToJson(PlayerB.SerializeToData());
Debug.Log(jsonPlayerA);
Debug.Log(jsonPlayerB);
Assert.AreEqual(jsonPlayerB, jsonPlayerA);
}
private void UpdateItems <T>() where T : Item
{
string itemType = typeof(T).FullName;
string aspectDatabasePath = "Assets/ScriptableObjects/Aspects/AspectDatabase.asset";
AspectDatabase aspectDatabase = (AspectDatabase)AssetDatabase.LoadAssetAtPath(aspectDatabasePath, typeof(AspectDatabase));
string itemsDir = Path.Combine(Path.Combine(jsonRootDir, "Items"), itemType);
foreach (string file in Directory.GetFiles(itemsDir, "*.json"))
{
string json = File.ReadAllText(file);
string name = new FileInfo(file).Name.Split('.')[0];
string path = string.Format("Assets/ScriptableObjects/Items/{0}/{1}.asset", itemType, name);
T item = default(T);
if (File.Exists(path))
{
item = (T)AssetDatabase.LoadAssetAtPath(path, typeof(T));
}
else
{
item = ScriptableObject.CreateInstance <T>();
SaveAsset(item, path);
}
item.AspectDatabase = aspectDatabase;
item.DeserializeFromJson(json);
string prefabPath = string.Format("Assets/Prefabs/Items/Items/{0}.asset", name);
if (File.Exists(prefabPath))
{
GameObject prefab = (GameObject)AssetDatabase.LoadAssetAtPath(prefabPath, typeof(GameObject));
item.Prefab = prefab;
}
string[] spriteFiles = Directory.GetFiles(string.Format("Assets/Sprites/Items/{0}", itemType), string.Format("{0}.*", name));
if (spriteFiles.Length > 0)
{
Sprite sprite = (Sprite)AssetDatabase.LoadAssetAtPath(spriteFiles[0], typeof(Sprite));
item.Sprite = sprite;
}
if (itemType == "Weapon")
{
string skillDatabasePath = "Assets/ScriptableObjects/Characters/Skills/SkillDatabase.asset";
SkillDatabase skillDatabase = (SkillDatabase)AssetDatabase.LoadAssetAtPath(skillDatabasePath, typeof(SkillDatabase));
Weapon weapon = item as Weapon;
string skill = Convert.ToString(SerializationUtilitites.DeserializeFromJson <Dictionary <string, object> >(json)["Skill"]);
weapon.Skill = skillDatabase.SkillByName(skill);
}
}
AssetDatabase.SaveAssets();
// TODO: Update the Database
}
public void Serialize_Inventory()
{
InventoryA.AddItem(TestItem, 10);
string json = SerializationUtilitites.SerializeToJson(InventoryA.SerializeToData());
InventoryB.DeserializeFromData(SerializationUtilitites.DeserializeFromJson <Dictionary <string, object> >(json));
Assert.AreEqual(InventoryA.Entries.Count, InventoryB.Entries.Count);
for (int i = 0; i < InventoryA.Entries.Count; i++)
{
Assert.AreEqual(InventoryA.Entries[i].Amount, InventoryB.Entries[i].Amount);
Assert.AreSame(InventoryA.Entries[i].Item, InventoryB.Entries[i].Item);
Assert.AreSame(Database.ItemByIdentifier <Item>(InventoryA.Entries[i].Item.Identifier), InventoryB.Entries[i].Item);
}
}
public void JsonSerialization()
{
string json = TestUtilities.JsonResourceFromFile("Item");
Item deserializedItem = ScriptableObject.CreateInstance <Item>();
JsonConvert.PopulateObject(json, deserializedItem);
Item fromSerialized = ScriptableObject.CreateInstance <Item>();
json = SerializationUtilitites.SerializeToJson(deserializedItem);
JsonConvert.PopulateObject(json, fromSerialized);
Assert.AreEqual(deserializedItem.Id, fromSerialized.Id);
Assert.AreEqual(deserializedItem.Name, fromSerialized.Name);
}
public override void DeserializeFromJson(string json)
{
base.DeserializeFromJson(json);
Dictionary <string, object> data = SerializationUtilitites.DeserializeFromJson <Dictionary <string, object> >(json);
Damage = Convert.ToInt32(data["Damage"]);
Speed = Convert.ToInt32(data["Speed"]);
List <AttackShapeMarker> attackShapes = new List <AttackShapeMarker>();
foreach (Dictionary <string, object> shapeData in SerializationUtilitites.DeserializeFromObject <Dictionary <string, object>[]>(data["AttackShape"]))
{
AttackShapeMarker attackShape = new AttackShapeMarker();
attackShape.DeserializeFromData(shapeData);
attackShapes.Add(attackShape);
}
AttackShape = attackShapes.ToArray();
}
public virtual void DeserializeFromJson(string json)
{
Dictionary <string, object> data = SerializationUtilitites.DeserializeFromJson <Dictionary <string, object> >(json);
Id = Convert.ToString(data["Id"]);
Name = Convert.ToString(data["Name"]);
Description = Convert.ToString(data["Description"]);
List <Aspect> aspects = new List <Aspect>();
foreach (string aspectName in SerializationUtilitites.DeserializeFromObject <string[]>(data["Aspects"]))
{
Aspect aspect = AspectDatabase.AspectByName(aspectName);
if (aspect != null)
{
aspects.Add(aspect);
}
}
Aspects = aspects.ToArray();
Tags = SerializationUtilitites.DeserializeFromObject <string[]>(data["Tags"]);
}
public void DeserializeFromData(Dictionary <string, object> data)
{
// Attributes
Name = Convert.ToString(data["Name"]);
Type = Convert.ToString(data["Type"]);
Health.DeserializeFromData(SerializationUtilitites.DeserializeFromObject <Dictionary <string, object> >(data["Health"]));
List <SkillSlot> skills = new List <SkillSlot>();
foreach (KeyValuePair <string, int> entry in SerializationUtilitites.DeserializeFromObject <Dictionary <string, int> >(data["Skills"]))
{
skills.Add(new SkillSlot(SkillDatabase.SkillByName(entry.Key), entry.Value));
}
Skills = skills.ToArray();
// Equipment
List <EquipmentSlot> equipment = new List <EquipmentSlot>();
foreach (KeyValuePair <string, object> entry in SerializationUtilitites.DeserializeFromObject <Dictionary <string, object> >(data["Equipment"]))
{
equipment.Add(new EquipmentSlot(entry.Key, ItemDatabase.ItemByIdentifier(Convert.ToString(entry.Value))));
}
Equipment = equipment.ToArray();
// Aspects and Tags
Tags = SerializationUtilitites.DeserializeFromObject <List <string> >(data["Tags"]);
Aspects = new List <Aspect>();
foreach (string name in SerializationUtilitites.DeserializeFromObject <string[]>(data["Aspects"]))
{
Aspects.Add(AspectDatabase.AspectByName(name));
}
// Other data
XP = Convert.ToInt32(data["XP"]);
SkillPoints = Convert.ToInt32(data["SkillPoints"]);
Radius = (float)Convert.ToDouble(data["Radius"]);
AlertnessRadius = (float)Convert.ToDouble(data["AlertnessRadius"]);
}
public void LoadGame()
{
string savedGameName = "SavedGame"; // TODO Replace this by a user provided name or the current date?
string rootPath = Path.Combine(_rootDataPath, savedGameName);
// Game State
string savePath = Path.Combine(rootPath, "GameSata.json");
string json = File.ReadAllText(savePath);
Dictionary <string, string> data = SerializationUtilitites.DeserializeFromJson <Dictionary <string, string> >(json);
InitializeGame(data);
Debug.Log(string.Format("Loaded Game from: {0}", savePath));
// Characters
savePath = Path.Combine(rootPath, "Characters");
foreach (string file in Directory.GetFiles(savePath, "*.json"))
{
json = File.ReadAllText(file);
PlayerCharacter player = Instantiate(PlayerPrefab);
player.DeserializeFromJson(json);
Debug.Log(string.Format("Loaded Character from: {0}", file));
}
}
public void NewGame()
{
Dictionary <string, string> data = SerializationUtilitites.DeserializeFromJson <Dictionary <string, string> >(DefaultGame.text);
InitializeGame(data);
}
