C# 如何在我的游戏中保存和加载进度？

我正在做一个2048游戏，遇到了一个保存和加载瓷砖位置的问题。每个人都知道游戏场的样子，有行也有列。因此，每个磁贴都有行索引（

indRow

）和列索引（

indCol

），它们设置了磁贴在游戏场上的位置。如何在游戏中保存此索引以在下一次开始时加载？
我的游戏管理器脚本=

using System.Collections
using System.Collections.Generic
using UnityEngine
using UnityEngine.UI
using UnityEngine.SceneManagement

public enum GameState
{
    Playing,
    GameOver,
    WaitingForMoveToEnd
}

public class GameManager : MonoBehaviour {

    //DELAYS
    public GameState State;
    [Range(0, 2f)]
    public float delay;
    private bool moveMade;
    private bool[] lineMoveComplete = new bool[4]{ true, true, true, true };

    public Text GameOverText;
    public Text GameOverScoreText;
    public GameObject GameOverPanel;

    private Tile[,] AllTiles = new Tile[4, 4];
    private List<Tile[]> columns = new List<Tile[]>();
    private List<Tile[]> rows = new List<Tile[]>();
    private List<Tile> EmptyTiles = new List<Tile>();

    // Use this for initialization
    void Start()
    {
            Tile[] AllTilesOneDim = GameObject.FindObjectsOfType<Tile>();
        foreach (Tile t in AllTilesOneDim)
        {
            t.Number = 0;
            AllTiles[t.indRow, t.indCol] = t;
            EmptyTiles.Add(t);

        }

        columns.Add (new Tile[] { AllTiles[0, 0], AllTiles[1, 0], AllTiles[2, 0], AllTiles[3, 0] });
        columns.Add (new Tile[] { AllTiles[0, 1], AllTiles[1, 1], AllTiles[2, 1], AllTiles[3, 1] });
        columns.Add (new Tile[] { AllTiles[0, 2], AllTiles[1, 2], AllTiles[2, 2], AllTiles[3, 2] });
        columns.Add (new Tile[] { AllTiles[0, 3], AllTiles[1, 3], AllTiles[2, 3], AllTiles[3, 3] });


        rows.Add (new Tile[] { AllTiles[0, 0], AllTiles[0, 1], AllTiles[0, 2], AllTiles[0, 3] });
        rows.Add (new Tile[] { AllTiles[1, 0], AllTiles[1, 1], AllTiles[1, 2], AllTiles[1, 3] });
        rows.Add (new Tile[] { AllTiles[2, 0], AllTiles[2, 1], AllTiles[2, 2], AllTiles[2, 3] });
        rows.Add (new Tile[] { AllTiles[3, 0], AllTiles[3, 1], AllTiles[3, 2], AllTiles[3, 3] });

        State = GameState.Playing;



            Generate();
        Generate();

    }

    private void GameOver()
    {
        State = GameState.GameOver;
        GameOverScoreText.text = ScoreTracker.Instance.Score.ToString();
        GameOverPanel.SetActive(true);
    }

    bool CanMove ()
    {
        if (EmptyTiles.Count > 0)
            return true;
        else
        {//check columns
            for (int i = 0; i < columns.Count; i++)
                for (int j = 0; j < rows.Count - 1; j++)
                    if (AllTiles[j, i].Number == AllTiles[j + 1, i].Number)

            return true;

            //check rows
            for (int i = 0; i < rows.Count; i++)
                for (int j = 0; j < rows.Count - 1; j++)
                    if (AllTiles[i, j].Number == AllTiles[i, j + 1].Number)

            return true;
        }
        return false;
    }

    public void NewGameButtonHandler()
    {
        Application.LoadLevel(Application.loadedLevel);
    }

    bool MakeOneMoveLeftIndex(Tile[] LineOfTiles)
    {
        for (int i = 0; i < LineOfTiles.Length - 1; i++)
        {
            //MOVE BLOCK
            if (LineOfTiles[i].Number == 0 && LineOfTiles[i + 1].Number != 0)
            {
                LineOfTiles[i].Number = LineOfTiles[i + 1].Number;
                LineOfTiles[i + 1].Number = 0;
                return true;
            }
            // MERGE BLOCK
            if (LineOfTiles[i].Number != 0 && LineOfTiles[i].Number == LineOfTiles[i + 1].Number &&
                LineOfTiles[i].mergedThisTurn == false && LineOfTiles[i + 1].mergedThisTurn == false)
            {
                LineOfTiles[i].Number *= 2;
                LineOfTiles[i + 1].Number = 0;
                LineOfTiles[i].mergedThisTurn = true;
                LineOfTiles[i].PlayMergeLeftAnimation();
                ScoreTracker.Instance.Score += LineOfTiles[i].Number;
                return true;
            }

        }
        return false;
    }

    bool MakeOneMoveDownIndex(Tile[] LineOfTiles)
    {
        for (int i = 0; i< LineOfTiles.Length-1; i++)
        {
            //MOVE BLOCK
            if (LineOfTiles[i].Number == 0 && LineOfTiles[i + 1].Number != 0)
            {
                LineOfTiles[i].Number = LineOfTiles[i + 1].Number;
                LineOfTiles[i + 1].Number = 0;
                return true;
            }
            // MERGE BLOCK
            if (LineOfTiles[i].Number!= 0 && LineOfTiles[i].Number == LineOfTiles[i+1].Number && 
                LineOfTiles[i].mergedThisTurn == false && LineOfTiles[i+1].mergedThisTurn ==false)
            {
                LineOfTiles[i].Number *= 2;
                LineOfTiles[i + 1].Number = 0;
                LineOfTiles[i].mergedThisTurn = true;
                LineOfTiles[i].PlayMergeDownAnimation();
                ScoreTracker.Instance.Score += LineOfTiles[i].Number;
                return true;
            }

        }
        return false;
    }

    bool MakeOneMoveRightIndex(Tile[] LineOfTiles)
    {
        for (int i = LineOfTiles.Length - 1; i > 0; i--)
        {
            //MOVE BLOCK
            if (LineOfTiles[i].Number == 0 && LineOfTiles[i - 1].Number != 0)
            {
                LineOfTiles[i].Number = LineOfTiles[i - 1].Number;
                LineOfTiles[i - 1].Number = 0;
                return true;
            }
            // MERGE BLOCK
            if (LineOfTiles[i].Number != 0 && LineOfTiles[i].Number == LineOfTiles[i - 1].Number &&
                LineOfTiles[i].mergedThisTurn == false && LineOfTiles[i - 1].mergedThisTurn == false)
            {
                LineOfTiles[i].Number *= 2;
                LineOfTiles[i - 1].Number = 0;
                LineOfTiles[i].mergedThisTurn = true;
                LineOfTiles[i].PlayMergeRightAnimation();
                ScoreTracker.Instance.Score += LineOfTiles[i].Number;
                return true;
            }

        }
        return false;
    }

    bool MakeOneMoveUpIndex(Tile[] LineOfTiles)
    {
        for (int i = LineOfTiles.Length-1; i > 0; i--)
        {
            //MOVE BLOCK
            if (LineOfTiles[i].Number == 0 && LineOfTiles[i-1].Number !=0)
            {
                LineOfTiles[i].Number = LineOfTiles[i - 1].Number;
                LineOfTiles[i - 1].Number = 0;
                return true;
            }
            // MERGE BLOCK
            if (LineOfTiles[i].Number != 0 && LineOfTiles[i].Number == LineOfTiles[i - 1].Number &&
                LineOfTiles[i].mergedThisTurn == false && LineOfTiles[i - 1].mergedThisTurn == false)
            {
                LineOfTiles[i].Number *= 2;
                LineOfTiles[i - 1].Number = 0;
                LineOfTiles[i].mergedThisTurn = true;
                LineOfTiles[i].PlayMergeUpAnimation();
                ScoreTracker.Instance.Score += LineOfTiles[i].Number;
                return true;
            }

        }
        return false;     
    }

    void Generate()
    {
        if (EmptyTiles.Count > 0)
        {
            int indexForNewNumber = Random.Range(0, EmptyTiles.Count);
            int randomNum = Random.Range(0, 10);
            if (randomNum == 0)
                EmptyTiles[indexForNewNumber].Number = 2;
            else
                EmptyTiles[indexForNewNumber].Number = 4;

            EmptyTiles[indexForNewNumber].PlayAppearAnimation();

                EmptyTiles.RemoveAt(indexForNewNumber);
        }
    }


    private void ResetMergedFlags()
    {
        foreach (Tile t in AllTiles)
            t.mergedThisTurn = false;
    }

    private void UpdateEmptyTiles()
    {
        EmptyTiles.Clear();
        foreach (Tile t in AllTiles)
        {
            if (t.Number == 0)
                EmptyTiles.Add(t);
        }
    }

    public void Move (MoveDirection md)
    {
        Debug.Log(md.ToString() + " move.");
        moveMade = false;
        ResetMergedFlags ();
        if (delay > 0)
            StartCoroutine(MoveCoroutine(md));
        else
        {
            for (int i = 0; i < rows.Count; i++)
            {
                switch (md)
                {
                    case MoveDirection.Down:
                        while (MakeOneMoveUpIndex(columns[i]))
                        {

                            moveMade = true;
                        }
                        break;
                    case MoveDirection.Left:
                        while (MakeOneMoveLeftIndex(rows[i]))
                        {
                            moveMade = true;
                        }
                        break;
                    case MoveDirection.Right:
                        while (MakeOneMoveRightIndex(rows[i]))
                        {
                            moveMade = true;
                        }
                        break;
                    case MoveDirection.Up:
                        while (MakeOneMoveDownIndex(columns[i]))
                        {
                            moveMade = true;
                        }
                        break;
                }
            }
            if (moveMade)
            {
                UpdateEmptyTiles();
                Generate();

                if (!CanMove())
                {
                    GameOver();
                }
            }

        }

    }

    IEnumerator MoveOneLineRightIndexCoroutine(Tile[] line, int index)
    {
        lineMoveComplete[index] = false;
        while (MakeOneMoveRightIndex(line))
        {
            moveMade = true;
            yield return new WaitForSeconds(delay);
        }
        lineMoveComplete[index] = true;
    }

    IEnumerator MoveOneLineUpIndexCoroutine(Tile[] line, int index)
    {
        lineMoveComplete[index] = false;
        while (MakeOneMoveUpIndex(line))
        {
            moveMade = true;
            yield return new WaitForSeconds(delay);
        }
        lineMoveComplete[index] = true;
    }

    IEnumerator MoveOneLineDownIndexCoroutine(Tile[] line, int index)
    {
        lineMoveComplete[index] = false;
        while (MakeOneMoveDownIndex(line))
        {
            moveMade = true;
            yield return new WaitForSeconds(delay);
        }
        lineMoveComplete[index] = true;
    }
        IEnumerator MoveOneLineLeftIndexCoroutine(Tile[] line, int index)
    {
        lineMoveComplete[index] = false;
        while (MakeOneMoveLeftIndex(line))
        {
            moveMade = true;
            yield return new WaitForSeconds(delay);
        }
        lineMoveComplete[index] = true;
    }

    IEnumerator MoveCoroutine(MoveDirection md)
    {
        State = GameState.WaitingForMoveToEnd;

        // start moving each line with delays depending on MoveDirection md
        switch (md)
        {
            case MoveDirection.Down:
                for (int i = 0; i < columns.Count; i++)
                    StartCoroutine(MoveOneLineUpIndexCoroutine(columns[i], i));
                break;
            case MoveDirection.Left:
                for (int i = 0; i < rows.Count; i++)
                    StartCoroutine(MoveOneLineLeftIndexCoroutine(rows[i], i));
                break;
            case MoveDirection.Right:
                for (int i = 0; i < rows.Count; i++)
                    StartCoroutine(MoveOneLineRightIndexCoroutine(rows[i], i));
                break;
            case MoveDirection.Up:
                for (int i = 0; i < columns.Count; i++)
                    StartCoroutine(MoveOneLineDownIndexCoroutine(columns[i], i));
                break;
        }
        // Wait until the move is over in all lines
        while (!(lineMoveComplete[0] && lineMoveComplete[1] && lineMoveComplete[2] && lineMoveComplete[3]))
            yield return null;

        if (moveMade)
        {
            UpdateEmptyTiles ();
            Generate();



            if (!CanMove())
            {
                GameOver();
            }


        }
        State = GameState.Playing;
            StopAllCoroutines();
    }
    public void ShowLeaderboards()
    {
        PlayGamesScript.ShowLeaderboardsUI();
    }
}

使用System.Collections
使用System.Collections.Generic
使用UnityEngine
使用UnityEngine.UI
使用UnityEngine.SceneManagement
公共枚举博弈状态
{
玩，
加梅奥弗，
等待前程结束
}
公共类GameManager:MonoBehavior{
//耽搁
公共博弈状态；
[范围（0，2f）]
公共交通延误；
私人住宅；
private bool[]lineMoveComplete=new bool[4]{true，true，true，true}；
公共文本游戏超文本；
公共文本；
公共游戏对象；
私人瓷砖[，]所有瓷砖=新瓷砖[4,4]；
私有列表列=新列表（）；
私有列表行=新列表（）；
私有列表EmptyTiles=新列表（）；
//用于初始化
void Start（）
{
Tile[]AllTilesOneDim=GameObject.FindObjectsOfType（）；
foreach（所有瓷砖内的瓷砖t）
{
t、 数字=0；
所有瓷砖[t.indRow，t.indCol]=t；
排空。添加（t）；
}
Add（新的Tile[]{AllTiles[0,0]，AllTiles[1,0]，AllTiles[2,0]，AllTiles[3,0]}）；
Add（新的Tile[]{AllTiles[0,1]，AllTiles[1,1]，AllTiles[2,1]，AllTiles[3,1]}）；
添加（新的Tile[]{AllTiles[0,2]，AllTiles[1,2]，AllTiles[2,2]，AllTiles[3,2]}）；
添加（新的Tile[]{AllTiles[0,3]，AllTiles[1,3]，AllTiles[2,3]，AllTiles[3,3]}）；
Add（新的Tile[]{AllTiles[0,0]，AllTiles[0,1]，AllTiles[0,2]，AllTiles[0,3]}）；
添加（新的Tile[]{AllTiles[1,0]，AllTiles[1,1]，AllTiles[1,2]，AllTiles[1,3]}）；
Add（新的Tile[]{AllTiles[2,0]，AllTiles[2,1]，AllTiles[2,2]，AllTiles[2,3]}）；
添加（新的Tile[]{AllTiles[3,0]，AllTiles[3,1]，AllTiles[3,2]，AllTiles[3,3]}）；
状态=游戏状态；
生成（）；
生成（）；
}
私有的void GameOver（）
{
State=GameState.GameOver；
GameOverScoreText.text=ScoreTracker.Instance.Score.ToString（）；
GameOverPanel.SetActive（true）；
}
布尔可以移动（）
{
如果（EmptyTiles.Count>0）
返回true；
其他的
{//检查列
for（int i=0；i0；i--）
{
//移动块
if（LineOfTiles[i].Number==0&&LineOfTiles[i-1].Number！=0）
{
LineOfTiles[i].Number=LineOfTiles[i-1].Number；
文件行[i-1]。编号=0；
返回true；
}
//合并块
if（LineOfTiles[i].Number！=0&&LineOfTiles[i].Number==LineOfTiles[i-1].Number&&
LineOfTiles[i].mergedThisTurn==false&&LineOfTiles[i-1].mergedThisTurn==false）
{
文件行[i]。编号*=2；
文件行[i-1]。编号=0；
LineOfTiles[i].MergedHisturn=true；
using System.IO;
using System.Xml.Serialization;

namespace Serialization
{
    class Program
    {
        static string file = @"C:\employees.xml"; // Path to our XML file. Could be anything else.
        static void Main(string[] args)
        {
            Person[] people;
            XmlSerializer xmlser = new XmlSerializer(typeof(Person[])); // Our XML serializer!
            if (File.Exists(file)) // If the file exists read it
            {
                using (Stream s = File.OpenRead(file)) // We need a stream for our serializer
                {
                    people = (Person[])xmlser.Deserialize(s); // Don't forget to cast the result.
                }
            }
            else // If the file doesn't exist we generate new data
            {
                people = new Person[] { new Person("John", "Doe"), new Person("Joe", "Swanson") };

                using (Stream s = File.OpenWrite(file)) // And then we save our new data.
                {
                    xmlser.Serialize(s, people);
                }
            }
        }

        // And now that we have something in people you can use it as you wish to.
    }

    public class Person // Our data class. Has to be public.
    {
        public Person() { } // Parameterless constructor used by XmlSerializer. IMPORTANT!!!
        public Person(string firstName, string surName)
        {
            FirstName = firstName;
            SurName = surName;
        }

        public string FirstName { get; set; }
        public string SurName { get; set; }
    }
}