Memo mode - unity

Memo mode

Memo mode is object behavior mode , Also known as snapshot mode , Without breaking encapsulation , Capture an object state and save , And when you need it , To restore .

In many games , We all have archiving function , Save the state during the archiving process . There are also many software with undo function , In addition to the storage of commands , And save the current state .
It is not difficult to save the state , But we need to protect the fields of the saved object , You can also save it . This is the black box .

Use here Double interface To complete the access to different classes .

Double interface

• Narrow interface ： Objects other than the initiator are obtained through narrow interfaces , This interface can only transfer objects , Cannot modify object .
• Wide interface ： Unlike narrow interfaces , The wide interface can access all the information in the object , Allow reading .

structure

explain

• Primary device （Originator） - Protect your state , And you can generate memo classes through snapshots to save your own state , You can also restore your state through snapshots .
• Memorandum （Memento） - An immutable value object （ read-only ）, Create new objects through construction . Save a snapshot .
• person in charge （Caretaker）- Be responsible for recording snapshots , And keep , Send a snapshot to the initiator to restore the state when necessary , You can manage snapshots , But it can't be modified .
• Narrow interface （I Memento） - As identifier , There's no way , The person in charge through the narrow interface （ black box ） To deliver .

Realization

The function of saving game archives
It uses SteamAssets Folder

Player information （ Primary device ） and Memorandum （ nesting ）

    public class PlayerInfo : MonoBehaviour
    {
    
        private FileSave _save;
        [SerializeField] private string _name;
        [SerializeField] private int _grade;
        [SerializeField] private int _attackForce;
        [SerializeField] private float _hp;

        private void Awake()
        {
    
            _save = new FileSave();
        }
		
		// The person in charge only works with serialized  Json  Dealing with strings 
        public void Save()
        {
    
            PlayerStateMemento memento = 
                new PlayerStateMemento(_name, _grade, _attackForce, _hp);
            string json = JsonUtility.ToJson(memento, true);

            _save.Save(json);
        }

        public void Restore()
        {
    
            string json = _save.ReadArchive();
            PlayerStateMemento memento = 
                JsonUtility.FromJson<PlayerStateMemento>(json);

            _name = memento.Name;
            _grade = memento.Grade;
            _attackForce = memento.AttackForce;
            _hp = memento.Hp;
        }
		
		// Immutable type , read-only 
        [Serializable]
        private class PlayerStateMemento
        {
    
            [SerializeField] private string _name;
            [SerializeField] private int _grade;
            [SerializeField] private int _attackForce;
            [SerializeField] private float _hp;

            public string Name => _name;
            public int Grade => _grade;
            public int AttackForce => _attackForce;
            public float Hp => _hp;
            
            public PlayerStateMemento(string name, int grade, int attackForce, float hp)
            {
    
                _name = name;
                _grade = grade;
                _attackForce = attackForce;
                _hp = hp;
            }
        }
    }

File saving class （ person in charge ）

    public class FileSave
    {
    
        private string _path;

        public FileSave()
        {
    
            CreateSaveFile();
        }

        public void Save(string json)
        {
    
            File.WriteAllText(_path, json);
        }

        public string ReadArchive()
        {
    
            return File.ReadAllText(_path);
        }

        private void CreateSaveFile()
        {
    
            if (!string.IsNullOrEmpty(_path)) return;
            _path = Application.streamingAssetsPath;

            if (!Directory.Exists(_path))
                Directory.CreateDirectory(_path);
                
            _path = Path.Combine(_path, "Save.json");
                
            if (!File.Exists(_path))
                File.Create(_path);
        }
    }

Test with two buttons

Successful file reading , Here are Json file

Application scenarios

• When you need to record the state of an object , And hope to restore the previous state .
• When you need to obtain different access permissions through dual interfaces

Advantages and disadvantages

advantage

• Without destroying the encapsulation , Create a snapshot of object state
• Snapshots can be maintained , To restore the previous state
  shortcoming
• Create snapshots too often , It may consume a lot of memory

Relationship with other models

• Use both command mode and memo mode to realize revoke The function of , under these circumstances , Commands are used for the operation of objects , The memo is used to restore the previous state .

In languages that do not support nested classes
We can use two interfaces to realize double interface operation