I've spent most of the last month
refactoring a lot of code, building in a basic campaign layer and then working
on the connection between the campaign/strategy layer and the tactical layer. I'll talk more about the campaign later, as today I wanted to talk about XML serialization in more detail.
XML Serialization effectively means I’m saving and
loading data to XML to persist game information on the hard disk.
When I start a mission, I populate my
mission object with the details I need to start the mission. At the moment, it’s
as simple as a level name, a list of player characters and a list of enemy
characters. The class looks a bit like this:
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Xml.Serialization;
public class Mission
{
public string LevelName { get; set; }
public List<Character> Players { get; set; }
public List<Character> Enemies { get; set; }
}
Loading and saving the mission is straight
forward with XML Serialization. Loading is basically opening the file with a StreamReader, De-Serializing the XML to the Mission object and returning the result. Saving is the inverse, creating a new file with the StreamWriter, Serializing the data to XML and then closing (saving) the save file.
public Mission LoadMission(string filePath)
{
Mission gameToLoad = new Mission();
StreamReader
streamReader = new StreamReader(filePath);
XmlSerializer reader
= new XmlSerializer(typeof(Mission));
return (Mission)reader.Deserialize(streamReader);
}
public bool SaveMission(string filePath, Mission gameToSave)
{
XmlSerializer writer
= new XmlSerializer(typeof(Mission));
StreamWriter file = new StreamWriter(filePath);
writer.Serialize(file,
gameToSave);
file.Close();
return true;
}
Let’s look a little closer at the Character
class I'm using for players and enemies and how that saves. It has a name, photo, health, AP’s, a chance to hit and a game object reference.
public class Character
{
public string Name { get; set; }
public string Photo { get; set; }
public int Health { get; set; }
public int ActionPointsRemaining { get; set; }
public int ChanceToHit { get; set; }
public CharacterObject GameObjectRef { get; set; }
}
Unfortunately, I can't directly serialize the GameObject type, (many binary types are not serializable), so I have to create a separate game object reference. They are big binary objects. At
the end of the day, this isn't a big deal, I really only need to know what sort
of game object the character is, the position/rotation/scale of the game object.
Below is this CharacterObject class, with enough details of the game object to
recreate it when I reload the level.
using UnityEngine;
using System;
using System.Collections;
using System.Xml.Serialization;
public class CharacterObject {
public string Name;
public string PrefabName;
public Vector3 Position;
public Quaternion Rotation;
public Vector3 Scale;
[XmlIgnore]
public GameObject GameObjectRef;
}
The result of all of this is the following XML,
with one player and no enemies.
<?xml version="1.0" encoding="utf-8"?>
<Mission xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<LevelName>IsometricCore</LevelName>
<Players>
<Character>
<Name>Sam</Name>
<Photo>Photos/Player</Photo>
<Health>10</Health>
<ActionPointsRemaining>1</ActionPointsRemaining>
<ChanceToHit>85%</ChanceToHit>
<CharacterObject>
<Name>Player1</Name>
<PrefabName>CharacterPrefab</PrefabName>
<Position>
<x>3.7499404</x>
<y>0.5</y>
<z>3.9403758</z>
</Position>
<Rotation>
<x>0</x>
<y>1</y>
<z>0</z>
<w>-1.62920685E-07</w>
<eulerAngles>
<x>0</x>
<y>180.000031</y>
<z>0</z>
</eulerAngles>
</Rotation>
<Scale>
<x>1</x>
<y>1</y>
<z>1</z>
</Scale>
<Tag>Player</Tag>
</CharacterObject>
</Character>
</Players>
<Enemies
/>
</Mission>
So what do we have to do to reload the GameObject again? We
just need to call the load, and then for each Player (or Enemy), recreate the
prefab object and put it back in the same location we saved.
// Initialize the mission object and load the mission xml file
Mission MissionData = new Mission();
MissionData.LoadMission(@"C:\mySaves\Mission1.xml");
if (MissionData != null)
{
foreach (Character item in MissionData.Players)
{
// Check to see if the player
object already exists
GameObject newObject = GameObject.Find(item.CharacterObject.Name);
// If we can’t find the object,
create it and attach it to the game object
if (newObject == null)
{
Object prefab =
UnityEditor.AssetDatabase.LoadAssetAtPath("Assets/Resources/" + item.CharacterObject.PrefabName + ".prefab", typeof(GameObject));
newObject = GameObject.Instantiate(prefab, Vector3.zero, Quaternion.identity) as GameObject;
// Transfer over the new properties
newObject.transform.position = item.CharacterObject.Position;
newObject.transform.rotation = item.CharacterObject.Rotation;
newObject.transform.localScale = item.CharacterObject.Scale;
newObject.name = item.CharacterObject.Name;
}
}
}
So that is it! We have reloaded the game object!
