public struct Stars{
public string starName;
public int StarType;//
public Vector3 position;
public Transform transform;
public MeshRenderer mrend_;
public Animation anim_;
public Collider coll_;
}

Stars _newStarInfoFrom(Stars _link,GameObject object_)
    {
        _link.transform = object_.GetComponent<Transform>();
        _link.mrend_ = object_.transform.GetChild(0).GetChild(0).GetComponent<MeshRenderer>();
        _link.anim_ = object_.GetComponent<Animation>();
        _link.coll_ = object_.transform.GetChild(0).GetComponent<Collider>();
        return _link;
    }
    Stars _newStarInfoFrom(string starName_, Vector3 pos_, int starType_)
    {
        Stars _newStarInfo;
        _newStarInfo.starName = starName_;
        _newStarInfo.StarType = starType_;
        _newStarInfo.position = pos_;
        return _newStarInfo;
    }

IEnumerator _StarDraw()
    {
        float dist2ship, /*-offset.z,*/star2cam, k, f;
        Material mat_;
        Color color_;
        while (true)
        {
            f = Mathf.Lerp(0.5f, 1, Vector3.Distance(ship.transform.position, cam.position) / solarsystem);
            for (int i = 0; i < starrange.Count; i++)
            {   
                dist2ship = Vector3.Distance(starrange[i].position, ship.transform.position);   
                // -offset.z = Vector3.Distance(starrange[i].position, cam.position);  
                switch (field)
                {     
                    case Field.Space:
                        Destroy(_star);
                        if (starrange[i].isDrawing[0] = dist2ship < drawRange[0] && -offset.z < LayerDis[0])
                        {   
                            if (!starrange[i].isGenerate)
                            {
                    _generateStars(i);
                    StartCoroutine(CreateStars(i));
                    break;
                            }
                            starrange[i].isDrawing[2] = dist2ship < drawRange[2] && -offset.z < LayerDis[2];
                            starrange[i].isDrawing[1] = starrange[i].isDrawing[2] ? true : dist2ship < drawRange[1] && -offset.z < LayerDis[1];
                            for (int c = 0; c < starsPrefab2D.Length; c++)
                            {
                    if (starrange[i].material[c] == null)
                    continue;
                    float distance = Mathf.Lerp(drawRange[_typeIdx(c)], drawRange[2], dist2ship / drawRange[2]);
                    k = (1 - -offset.z / LayerDis[_typeIdx(c)]) * (1 - dist2ship / distance) * (spaceMenu_.uiActive ? 0.25f : 1f);
                    mat_ = starrange[i].material[c];
                    color_ = mat_.GetColor("_TintColor");
                    mat_.SetColor("_TintColor", new Vector4(color_.r, color_.g, color_.b, k));
                            }
                            for (int s = 0; s < _roundLayer; s++)
                            {   
                    int idx = _typeIdx(stars[i, s].StarType);
                    if (!starrange[i].isDrawing[idx])
                    continue;
                    stars[i, s].mrend_.enabled = starrange[i].isDrawing[idx];
                    stars[i, s].anim_.enabled = starrange[i].isDrawing[idx];
                    stars[i, s].transform.LookAt(cam.position);
                    star2cam = Vector3.Distance(stars[i, s].position, cam.position);
                    stars[i,s].coll_.enabled = star2cam<flyDist;
                    float scale = star2cam/ _radius;
                    stars[i, s].transform.localScale = Vector3.one*scale;
                            }
                        }
                        else
                        {
                            if (!starrange[i].isGenerate)
                    continue;
                            if (dist2ship > 1000 && Cleaner == null)
                            {
                    Cleaner = StartCoroutine(_clearStars(i));
                    continue;
                            }
                            if (starrange[i].isDrawing[0])
                            {
                    for (int s = 0; s < _roundLayer; s++)
                    {
                    if (!starrange[i].isGenerate)
                    break;
                    if (stars[i, s].transform == null)
                    break;
                    stars[i, s].mrend_.enabled = false;
                    stars[i, s].anim_.enabled = false;
                    stars[i, s].coll_.enabled = false;
                    }
                    starrange[i].isDrawing[0] = false;
                            }
                        }
                        break;
                        case Field.Solar_System:
                        if (dist2ship < drawRange[2])
                        {
                            for (int s = 0; s < _roundLayer; s++)
                            {   
                    if (stars[i, s].transform == null)
                    break;
                    if (!starrange[i].isDrawing[_typeIdx(stars[i, s].StarType)])
                    continue;
                    if (stars[i, s].mrend_.enabled)
                    {
                    stars[i, s].transform.LookAt(cam.position);
                    float scale = Vector3.Distance(stars[i, s].position, cam.position) / _radius  * f;
                    stars[i, s].transform.localScale = Vector3.one*scale;
                    }
                    if (_star == null && target == null ? false : target.position == stars[i, s].position)
                    _star = Instantiate(starsPrefab3D[stars[i, s].StarType], stars[i, s].position, Quaternion.identity);
                            }
                        }
                        break;
                }
            }   
            yield return new WaitForFixedUpdate();
        }

public void _generateStars(int i)
    {   
        starrange[i].isGenerate = true;
        for (int g = 0; g < _roundLayer; g++)
        {
            int type = UnityEngine.Random.Range(0, 8);
            Vector3 _v = _GeneratePos(i);    
            string gName = main._generateName();
            stars[i,g] = _newStarInfoFrom(gName,_v,type);
        }
    }

IEnumerator CreateStars(int i)
    {   
        for (int g = 0; g < _roundLayer; g++)
        {
            GameObject new_ = Instantiate(starsPrefab2D[stars[i, g].StarType], stars[i, g].position, Quaternion.identity);
            stars[i, g] = _newStarInfoFrom(stars[i, g],new_);
            Material globalMaterial = starrange[i].material[stars[i, g].StarType];
            Material localMaterial = new_.transform.GetChild(0).GetChild(0).GetComponent<Renderer>().material;
            if (globalMaterial == null)
                globalMaterial = localMaterial;
            else
                localMaterial = globalMaterial;
            starrange[i].material[stars[i, g].StarType] = globalMaterial;
            new_.transform.GetChild(0).GetChild(0).GetComponent<Renderer>().material = localMaterial;
            new_.gameObject.name = stars[i, g].starName;
            yield return new WaitForFixedUpdate();
        }
    }

IEnumerator _clearStars(int i)//Не стоит скапливаться обьектам
    {
        starrange[i].isGenerate = false;
        for(int s = 0;s<_roundLayer;s++)
        {
            yield return new WaitForFixedUpdate();
            Destroy(stars[i,s].transform.gameObject);
        }
        StopCoroutine(Cleaner);
        Cleaner = null;
    }

public struct Star
    {
        public string starName;
        public int StarType;
        public Vector3 position;
        public Transform transform;
        public MeshRenderer mrend_;
        // public Animation anim_;
        public Collider coll_;
        public Planet[] planet;
        public bool[] orbIsBusy;
        //===============
        public class Planet
        {
            public string planetName;
            public MeshRenderer mrend_;
            public localPos position;

            public struct localPos
            {
                public float angle, scale;
                public int orb;

                public localPos(float angle_, float scale_, int orb_)
                {
                    angle = angle_;
                    scale = scale_;
                    orb = orb_;
                }
            }
        }
        ///===========================
    }