public struct myVector3
{
public float x, y, z;
public float rot_x, rot_y, rot_z;
}

foreach (var obj in GameObject.FindGameObjectsWithTag("Cube1"))

{
myVector3 i = new myVector3();

i.x = obj.transform.position.x;
i.y = obj.transform.position.y;
i.z = obj.transform.position.z;

i.rot_x = obj.transform.eulerAngles.x;
i.rot_y = obj.transform.eulerAngles.y;
i.rot_z = obj.transform.eulerAngles.z;

ObjectsPositions.Add(i);
}

public void BackMyCubes()
{
ObjectsPositions = Load();

foreach (var obj in ObjectsPositions)
{
GameObject i = Instantiate(Cube1Pref, new Vector3(obj.x, obj.y, obj.z), Quaternion.identity);
i.transform.Rotate(obj.rot_x, obj.rot_y, obj.rot_z, Space.World)
}
ObjectsPositions.Clear();
}

public Dictionary<string, Level> levels = new Dictionary<string, Level>();
public struct Corpse
{
    public string type;
    public int x;
    public int y;
}

[System.Serializable]
public struct Point
{
    public float X;
    public float Y;
    public float Z;
    public Point(float x, float y, float z)
    {
        X = x;
        Y = y;
        Z = z;
    }
}
[System.Serializable]
public struct Enemy
{
    public string type;
    public Point pos;
    public Point rot;
    public int hp;
    public AI_cult_1.State state;
    public int ammo;
    public bool vis;
}

[System.Serializable]
public struct Decoration
{
    public string type;
    public Point pos;
    public Point rot;
}

[System.Serializable]
public struct Level
{
    public List<Corpse> corpses;
    public List<Enemy> enemies;
    public List<Decoration> decorations;

Level lvl = new Level();

        lvl.decorations = GetAllDecor();//берем все декорации на сцене
        lvl.enemies = GetAllEnemies();//находим всех противников на сцене
        
        if (!levels.ContainsKey(SceneManager.GetActiveScene().name)) //если нет уровня в дикте
        {levels.Add(SceneManager.GetActiveScene().name,lvl);}        //то создадим его
        else
        {levels[SceneManager.GetActiveScene().name]=lvl;} //а если есть - перезапишем

    public List<Decoration> GetAllDecor()
    {
        List<Decoration> lol = new List<Decoration>();
        GameObject[] decors = GameObject.FindGameObjectsWithTag("Decoration");
        foreach (GameObject decor in decors)
        {
            Decoration a = new Decoration();
            a.type = decor.name;
            a.pos = new Point(decor.transform.position.x,decor.transform.position.y,decor.transform.position.z);
            a.rot = new Point(decor.transform.eulerAngles.x,decor.transform.eulerAngles.y,decor.transform.eulerAngles.z);
            lol.Add(a);
        }
        
        return lol;

    }

    public List<Enemy> GetAllEnemies()
    {
        List<Enemy> lol = new List<Enemy>();
        AI_cult_1[] enemies_on_scene = Object.FindObjectsOfType<AI_cult_1>();
        foreach (AI_cult_1 enemy in enemies_on_scene)
        {
            Enemy a = new Enemy();
            a.type = enemy.name;
            a.pos = new Point(enemy.transform.position.x,enemy.transform.position.y,enemy.transform.position.z);
            a.rot = new Point(enemy.transform.eulerAngles.x,enemy.transform.eulerAngles.y,enemy.transform.eulerAngles.z);
            a.ammo = enemy.countAmmo;
            a.hp = enemy.hp;
            a.state = enemy.state;
            a.vis = enemy.vis;
            lol.Add(a);
        }

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
using UnityEngine.UI;

public class SaveGameToM : MonoBehaviour
{
    public GameObject Cube1Pref;
    public GameObject Triangle1Pref;

    [System.Serializable]
    public struct myVector3
    {
        public float x, y, z;
    }

    [System.Serializable]
    public struct myVector4
    {
        public float j, k, l;
    }

    [SerializeField] public List<myVector3> ObjectsPositions = new List<myVector3>();
    [SerializeField] public List<myVector4> ObjectsPositionsT = new List<myVector4>();
    

    public void Start()
    {
        if (File.Exists(Application.persistentDataPath + "/saves/save.sav"))
        {
            BackMyCubes();
            BackMyTriangles();
        }
    }

    public void BackMyCubes()
    {
        ObjectsPositions = Load();

        foreach (var pos in ObjectsPositions)
        {
            GameObject i = Instantiate(Cube1Pref, new Vector3(pos.x, pos.y, pos.z), Quaternion.identity);
        }
        ObjectsPositions.Clear();
    }

    public void BackMyTriangles()
    {
        ObjectsPositionsT = LoadT();

        foreach (var posT in ObjectsPositionsT)
        {
            GameObject t = Instantiate(Triangle1Pref, new Vector4(posT.j, posT.k, posT.l), Quaternion.identity);
        }
        ObjectsPositionsT.Clear();
    }

    public void ManualSaving()
    {
        foreach (var obj in GameObject.FindGameObjectsWithTag("Cube1"))
        {
            myVector3 i = new myVector3();
            i.x = obj.transform.position.x;
            i.y = obj.transform.position.y;
            i.z = obj.transform.position.z;
           
            ObjectsPositions.Add(i);
        }
        SaveCu(ObjectsPositions);
    }

    public void ManualSavingT()
    {
        foreach (var objT in GameObject.FindGameObjectsWithTag("Triangle1"))
        {
            myVector4 t = new myVector4();
            t.j = objT.transform.position.x;
            t.k = objT.transform.position.y;
            t.l = objT.transform.position.z;

            ObjectsPositionsT.Add(t);
        }
        SaveT(ObjectsPositionsT);
    }

    public List<myVector3> Load()
    {
        List<myVector3> objects;
        
        BinaryFormatter formatter = new BinaryFormatter();
        using (FileStream stream = new FileStream(Application.persistentDataPath + "/saves/save.sav", FileMode.Open))
        {
            objects = (List<myVector3>)formatter.Deserialize(stream);
        }
        return objects;
    }

    public List<myVector4> LoadT()
    {
        List<myVector4> objectsT;
        BinaryFormatter formatter = new BinaryFormatter();
        using (FileStream streamT = new FileStream(Application.persistentDataPath + "/saves/save.sav", FileMode.Open))
        {
            objectsT = (List<myVector4>)formatter.Deserialize(streamT);
        }
        return objectsT;
    }

    void SaveCu(List<myVector3> positions)
    {

        BinaryFormatter formatter = new BinaryFormatter();
        using (FileStream stream = new FileStream(Application.persistentDataPath + "/saves/save.sav", FileMode.Create))
        {
            formatter.Serialize(stream, positions);
            stream.Close();
        }
        positions.Clear();
    }

    void SaveT(List<myVector4> positionsT)
    {
        BinaryFormatter formatter = new BinaryFormatter();
        using (FileStream streamT = new FileStream(Application.persistentDataPath + "/saves/save.sav", FileMode.Append))
        {
            formatter.Serialize(streamT, positionsT);
            streamT.Close();
        }
        positionsT.Clear();

    }
}

InvalidCastException: Specified cast is not valid. SaveGameToM.LoadT () (at Assets / Script / SaveGameToM.cs: 111)