06、游戏的存档和读档

1、保存的数据类：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

[System.Serializable]
public class Save
{
    public List<int> livingTargetPosition = new List<int>();       //用来保存有怪物的位置信息
    public List<int> livingMonsterType = new List<int>();          //保存生成的怪物类型

    public int shootNumebr=0;           //射击数
    public int score = 0;        //分数
}

2、游戏管理器，用来管理游戏的保存和加载

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;           //二进制转换器
using LitJson;              //json的命名空间引入
using System.Xml;           //引入xml的命名空间
    
public class GameManager : MonoBehaviour
{
    private static GameManager _instance;
    public static GameManager Instace
    {
        get
        {
            return _instance;
        }
        set
        {
            _instance = value;
        }
    }
    private void Awake()
    {
        _instance = this;

    }

    public GameObject MenuGameObject;              //菜单游戏物体
    public GameObject[] targets;                   //每个格子都会有怪物生成，则要一一获取
    public bool IsPause = true;                     //默认菜单面板显示出来就是暂停状态

    private void Start()
    {
        IsPause = true;
        Pause();                                    //默认菜单面板显示出来就是暂停状态
    }

    private void Update()
    {
        if (Input.GetKeyDown(KeyCode.Escape))
        {
            Pause();                         //当按下了ESC键就调出菜单面板
        }
    }

    /// <summary>
    /// 通过生成的游戏数据，然后创建保存类，将相关的数据写到Sava类中进行保存
    /// //只要调用这个方法，就会得到一个保存好数据的Save类
    /// </summary>
    /// <returns></returns>
    private Save CreateSave()
    {
        Save save = new Save();     //先创建这个对象
        foreach (GameObject targetGo in targets)
        {
            TargetManager targetManager = targetGo.GetComponent<TargetManager>();
            if(targetManager.activateMoster!=null)
            {
                //如果有不为空的，也就是在游戏场景中生成了的,
                save.livingTargetPosition.Add(targetManager.targetPosition);            //则要进行保存
                save.livingMonsterType.Add(targetManager.activateMoster.GetComponent<MosterManager>().mosterType);  //保存怪物类型
            }
        }
        save.shootNumebr = UIManager.Instance.shootNumber;
        save.score = UIManager.Instance.scoreNumber;                //将分数和射击数进行保存

        return save;        
    }
    /// <summary>
    /// 通过读档，将得到的数据运用到游戏中，分数、射击数、怪物位置、怪物类型
    /// </summary>
    /// <param name="save">读取到的文件类</param>
    private void SetGame(Save save)
    {
        foreach (GameObject targetGo in targets)
        {
            targetGo.GetComponent<TargetManager>().UpdateMoster();      //通过数据读取来设计游戏中的场景时，要先将场景中有的进行清空
        }

        for (int i = 0; i < save.livingTargetPosition.Count; i++)
        {
            int position = save.livingTargetPosition[i];            //得到在哪个格子里面进行生成
            int type = save.livingMonsterType[i];                   //得到生成那种类型的
            targets[position].GetComponent<TargetManager>().ActivateMonsterByType(type);        //通过怪物下标来进行生成
        }

        UIManager.Instance.shootNumber = save.shootNumebr;
        UIManager.Instance.scoreNumber = save.score;                //更新得分和成绩
    }




    //二进制：存档和读档
    private void SaveByBin()
    {
        //1、首先得到要保存的Save类
        Save save = CreateSave();          
        //2、创建一个二进制转化程序
        BinaryFormatter binF = new BinaryFormatter();
        //3、得到要保存数据的数据流
        FileStream fileStream = File.Create(Application.dataPath + "/StreamingFile" + "/Bin.txt");
        //4、进行序列化，写入
        binF.Serialize(fileStream, save);
        //5、关闭
        fileStream.Close();

        if(File.Exists((Application.dataPath + "/StreamingFile" + "/Bin.txt")))
        {
            //如果保存成功了，显示保存成功的提示
            UIManager.Instance.Message("保存成功");
        }
    }

    private void LoadByBin()
    {
        //1、先判断存档文件是否存在
        if(File.Exists(Application.dataPath + "/StreamingFile" + "/Bin.txt"))
        { 
            //2、创建二进制转换器
            BinaryFormatter binf = new BinaryFormatter();
            //3、得到文件流
            FileStream fileStrem = File.Open(Application.dataPath + "/StreamingFile" + "/Bin.txt", FileMode.Open);
            //4、通过二进制逆转换器得到数据
            Save save = (Save)binf.Deserialize(fileStrem);      //得到数据
            //5、关闭
            fileStrem.Close();
            //6、将数据进行保存
            SetGame(save);

            UIManager.Instance.Message("读档成功");
        }
        else
        {
            UIManager.Instance.Message("文档不存在");
        }
    }


    //XML：存档和读档
    private void SaveByXml()
    {
        //1、创建save对象
        Save save = CreateSave();
        //2、创建XML文件的存储路径
        string filePath = Application.dataPath + "/StreamingFile" + "/byXml.xml";
        //3、创建XML文档
        XmlDocument xmlDoc = new XmlDocument();
        //4、创建根节点,名字为Save，注意，一个XML文档只有一个根节点，就和html语言一样
        XmlElement root = xmlDoc.CreateElement("Save");
        //5、设置根节点的属性，也可以不设置
        root.SetAttribute("namne","saveFile");

        //6、创建XmlElement
        XmlElement target;
        XmlElement targetPosition;
        XmlElement targetType;

        for (int i = 0; i < save.livingTargetPosition.Count; i++)
        {
            target = xmlDoc.CreateElement("Target");

            //创建其中一个属性 设置innertext的值
            targetPosition = xmlDoc.CreateElement("targetPosition");
            targetPosition.InnerText = save.livingTargetPosition[i].ToString();

            targetType = xmlDoc.CreateElement("targetType");
            targetType.InnerText = save.livingMonsterType[i].ToString();

            //设置层级关系
            target.AppendChild(targetPosition);
            target.AppendChild(targetType);
            root.AppendChild(target);
        }
        XmlElement UI;
        XmlElement shootNumber;
        XmlElement score;

        UI = xmlDoc.CreateElement("UI");
        shootNumber = xmlDoc.CreateElement("ShootNumber");
        score = xmlDoc.CreateElement("Score");

        //存入数据
        shootNumber.InnerText = save.shootNumebr.ToString();
        score.InnerText = save.score.ToString();

        //设置层级关系
        UI.AppendChild(shootNumber);
        UI.AppendChild(score);
        root.AppendChild(UI);

        //将根节点添加到xml文档中
        xmlDoc.AppendChild(root);
        //保存xml文档
        xmlDoc.Save(filePath);

        if(File.Exists(filePath))
        {
            UIManager.Instance.Message("保存成功");
        }

    }
    private void LoadByXml()
    {
        string filePath= Application.dataPath + "/StreamingFile" + "/byXml.xml";
        //如果存在文件的话
        if(File.Exists(filePath))
        {
            Save save = new Save();
            //加载XML文档
            XmlDocument xmlDoc = new XmlDocument();
            xmlDoc.Load(filePath);
            //通过节点名称来获取元素，注意，文档中会有多个该节点，结果为XmlNodeList类型
            XmlNodeList targets =xmlDoc.GetElementsByTagName("Target");
            if(targets.Count!=0)
            {
                for (int i = 0; i < targets.Count; i++)
                {
                    //每一个target节点下面还有子节点，数据存在了对应的子节点下面
                    XmlNode targetPosition = targets[i].ChildNodes[0];
                    int targetPositionValue = int.Parse(targetPosition.InnerText);
                    save.livingTargetPosition.Add(targetPositionValue);

                    XmlNode targetType = targets[i].ChildNodes[1];
                    int targetTypeValue = int.Parse(targetType.InnerText);
                    save.livingMonsterType.Add(targetTypeValue);

                }
            }

            XmlNodeList UI = xmlDoc.GetElementsByTagName("UI");
            if(UI.Count!=0)
            {
                foreach (XmlNode ui in UI)
                {
                    XmlNode shootNumber = ui.ChildNodes[0];
                    int shootNumberValue = int.Parse(shootNumber.InnerText);
                    save.shootNumebr = shootNumberValue;

                    XmlNode score = ui.ChildNodes[1];
                    int scoreValue = int.Parse(score.InnerText);
                    save.score = scoreValue;
                }
            }

            //将得到的数据进行应用
            SetGame(save);      

            UIManager.Instance.Message("文档加载成功");
        }
        else
        {
            UIManager.Instance.Message("文档不存在");
        }

        

    }


    //JSON：存档和读档
    private void SaveByJson()
    {
        //1、创建save对象
        Save save = CreateSave();
        //2、得到要放置json文件的地址
        string filePath = Application.dataPath + "/StreamingFile" + "/byJson.json";
        //3、将save对象转换为json字符串
        string saveJsonString = JsonMapper.ToJson(save);
        //4、 //设置为写入的文件流
        StreamWriter writer = new StreamWriter(filePath);
        //5、写入
        writer.Write(saveJsonString);
        //6、关闭
        writer.Close();
        if(File.Exists(Application.dataPath + "/StreamingFile" + "/byJson.json"))
        {
            UIManager.Instance.Message("保存成功");
        }


    }
    private void LoadByJson()
    {
        string filrPath = Application.dataPath + "/StreamingFile" + "/byJson.json";
        if(File.Exists(filrPath))
        {
            //1、如果文件存在
            StreamReader reader = new StreamReader(filrPath);
            //2、通过读取数据流读到json文件中的信息，转化为字符串
            string loadJsonString = reader.ReadToEnd();         //读取到结尾
            //3、将json文件转化为save对象
            Save save = JsonMapper.ToObject<Save>(loadJsonString);
            //4、将数据应用到游戏中
            SetGame(save);
            UIManager.Instance.Message("读取成功");
        }
        else
        {
            UIManager.Instance.Message("文档不存在");
        }

    }

    /// <summary>
    /// 暂停游戏
    /// </summary>
    private void Pause()
    {
        MenuGameObject.SetActive(true);
        IsPause = true;
        Time.timeScale = 0;         //暂停游戏
        Cursor.visible = true;
    }


    /// <summary>
    /// 非暂停状态
    /// </summary>
    private void UpPause()
    {
        IsPause = false;
        MenuGameObject.SetActive(false);
        Time.timeScale = 1;         //继续进行游戏
        Cursor.visible = false;
    }

    /// <summary>
    /// 继续游戏
    /// </summary>
    public void OnContinueGameButtonClick()
    {
        UpPause();
    }

    /// <summary>
    /// 退出游戏
    /// </summary>
    public void OnQuietButtonClick()
    {
    #if UNITY_EDITOR
         UnityEditor.EditorApplication.isPlaying = false;
    # else
         Application.Quit();    
    #endif
    }

    /// <summary>
    ///新游戏
    /// </summary>
    public void OnNewGameButtonClick()
    {
        foreach (GameObject target in targets)
        {
            target.GetComponent<TargetManager>().UpdateMoster();            //对场景中的每一个敌人进行消息传递，进行更新
        }
        UIManager.Instance.shootNumber = 0;
        UIManager.Instance.scoreNumber = 0;         //将分数进行清零
        UpPause();
    }

    /// <summary>
    /// 保存数据
    /// </summary>
    public void OnSaveButtonClick()
    {
        UIManager.Instance.Message("");
        //SaveByBin();            //二进制保存
        //SaveByJson();
        SaveByXml();
        StartCoroutine(HideMessage());
    }

    /// <summary>
    /// 加载数据
    /// </summary>
    public void OnLoadButtonClick()
    {
        UIManager.Instance.Message("");
        //LoadByBin();
        //LoadByJson();
        LoadByXml();
        StartCoroutine(HideMessage());
    }

    /// <summary>
    /// 在一定时间内将帮助文档进行隐藏
    /// </summary>
    /// <returns></returns>
   IEnumerator HideMessage()
    {
        yield return new WaitForSeconds(1.0f);
        UIManager.Instance.message_Text.gameObject.SetActive(false);
    }
}

3、显示TargetManager和UIManager两个类方便阅读

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class UIManager : MonoBehaviour
{

    private static UIManager _instace;
    public static UIManager Instance
    {
        set
        {
            _instace = value;
        }
        get
        {
            return _instace;
        }
    }
    private void Awake()
    {
        _instace = this;
    } 

    public Text shootNumber_Text;
    public Text scoreNumber_Text;
    public Toggle musicToggle;
    public Text message_Text;           //用来显示保存、加载成功的

    public int shootNumber = 0;
    public int scoreNumber = 0;

    public AudioSource music;


    private void Start()
    {
        message_Text.gameObject.SetActive(false);
    }

    private void Update()
    {
        UpdateUI();     //更新UI显示   



        //如果存在声音控制的键值
        if(PlayerPrefs.HasKey("MusicOn"))
        {
            if(PlayerPrefs.GetInt("MusicOn")==0)
            {
                musicToggle.isOn = false;
                music.enabled = false;
            }
            else if(PlayerPrefs.GetInt("MusicOn")==1)
            {
                musicToggle.isOn = true;
                music.enabled = true;
            }
        }
        //如果不存在这个键的话，就默认设置为播放状态
        else
        {
            musicToggle.isOn = true;
            music.enabled = true;
        }


    }


    /// <summary>
    /// 声音开光控制
    /// 使用了PlayerPrefs的保存方法来进行保存
    /// </summary>
    public void MusicSwitch()
    {
        if(musicToggle.isOn==true)
        {   
            music.enabled = true;
            PlayerPrefs.SetInt("MusicOn", 1);           //为1表示播放音乐，为0表示暂停音乐
        }
        else
        {        
            music.enabled = false;
            PlayerPrefs.SetInt("MusicOn", 0);
        }

        PlayerPrefs.Save();         //注意，在设置完值后，一定要进行保存，否则结果是无法进行保存的
    }





    /// <summary>
    /// 更新Ui显示的方法
    /// </summary>
    private void UpdateUI()
    {
        shootNumber_Text.text = shootNumber.ToString();
        scoreNumber_Text.text = scoreNumber.ToString();
    }
    /// <summary>
    /// 增加射击数的
    /// </summary>
    public void AddShootNumber()
    {
        shootNumber += 1;
    }

    /// <summary>
    /// 增加分数的
    /// </summary>
    public void AddScoreNumber()
    {
        scoreNumber += 1;
    }

    /// <summary>
    /// 显示加载、保存成功的提示消息的
    /// </summary>
    /// <param name="message">保存成功、保存失败</param>
    public void Message(string message)
    {
        message_Text.text = message;
        message_Text.gameObject.SetActive(true);
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class TargetManager : MonoBehaviour
{
    //这里不能用单例模式，因为在游戏中会生成多个相同的对象，
    //到后面就不能正确的知道是那个TargetManager了
    //private static TargetManager _instance;
    //public static TargetManager Instance
    //{
    //    get
    //    {
    //        return _instance;
    //    }
    //    set
    //    {
    //        _instance = value;
    //    }
    //}
    //private void Awake()
    //{
    //    _instance = this;
    //}

    public GameObject[] mosters;
    public GameObject activateMoster=null;         //这个是用来取得当前实例出来的怪物
    public int targetPosition;          //用来设置怪物的生成位置，要被保存的

    private void Start()
    {
        //一开始先做预判的处理
        foreach (GameObject moster in mosters)
        {
            moster.GetComponent<BoxCollider>().enabled = false;
            moster.SetActive (false);
        }
        StartCoroutine(AliveTiemr());
    }



    /// <summary>
    /// 等待多久进行怪物的生成的协程
    /// </summary>
    /// <returns></returns>
    IEnumerator AliveTiemr()
    {
        yield return new WaitForSeconds(Random.Range(1, 5));            //等待个随机1-4秒再生成
        ActivateMoster();
        StartCoroutine(DeathTimer());
    }

    /// <summary>
    /// 控制怪物在生成一段时间后自动进行消失
    /// </summary>
    /// <returns></returns>
    IEnumerator DeathTimer()
    {
        yield return new WaitForSeconds(Random .Range(3f,8.0f));
        DeActivateMoster();
    }



    /// <summary>
    /// 将小怪物进行激活
    /// </summary>
    private void ActivateMoster()
    {
        int index = Random.Range(0, mosters.Length);            //取得随机的生成怪物的下标
        activateMoster = mosters[index];
        activateMoster.SetActive(true);
        activateMoster.GetComponent<BoxCollider>().enabled = true;
    }

    /// <summary>
    /// 将怪物进行隐藏
    /// </summary>
    private void DeActivateMoster()
    {
        if(activateMoster!=null)
        {
            activateMoster.GetComponent<BoxCollider>().enabled = false;
            activateMoster.SetActive(false);
            activateMoster = null;
        }
       StartCoroutine(AliveTiemr());

    }

    /// <summary>
    /// 当怪物被打死后，让外界（MosterManager）进行调用重新再生成一波敌人
    /// </summary>
    public void UpdateMoster()
    {
        StopAllCoroutines();            //现将所有的协程进行暂停，避免出现协程没运行完，就开始生成下一波怪物了
        if (activateMoster!=null)
        {
            activateMoster.GetComponent<BoxCollider>().enabled = false;
            activateMoster.SetActive(false);
            activateMoster = null;
        }
        StartCoroutine(AliveTiemr());
    }


    /// <summary>
    /// 通过指定的怪物类型来进行怪物的生成
    /// 放在游戏加载的时候被调用
    /// </summary>
    /// <param name="type">怪物下标类型</param>
    public void ActivateMonsterByType(int type)
    {
        StopAllCoroutines();            //先停止所有的协程
        if(activateMoster!=null)
        {
            activateMoster.GetComponent<BoxCollider>().enabled = false;
            activateMoster.SetActive(false);
            activateMoster = null;          
        }
        activateMoster = mosters[type];         //通过怪物类型来进行生成
        activateMoster.SetActive(true);
        activateMoster.GetComponent<BoxCollider>().enabled = true;
        StartCoroutine(DeathTimer());           //怪物生成出来了，就要等待被删除了

    }
}

4、希望可以帮助到大家，这也是自己总结出来的，有错误希望大家帮忙指正。

【注意：】使用JSON的话要导入Json库！！！