XiuXianProject/GameClient/Assets/Game/HotUpdate/Data/PhotographSceneManager.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using cfg.GfgCfg;
using ET;
using UnityEngine;
using YooAsset;

namespace GFGGame
{
    public class PhotographSceneManager : SingletonBase<PhotographSceneManager>
    {
        public GameObject sceneObject;

        public async void AddBgItem(ItemCfg itemCfg)
        {
            Transform tf = sceneObject.transform.Find("Bg/BgRes");
            string resPath = ResPathUtil.GetSceneBgPath(itemCfg.Res);
            await LoadManager.Instance.CheckResExsitedOrDownload(resPath);
            SetSpriteRendererToTransform(tf, resPath);
            SpriteRenderer spr = tf.GetComponent<SpriteRenderer>();
            spr.sortingOrder = -4000;
            SetBoxCollider2DToGameObject(tf.gameObject);
        }

        public void AddBorderItem(ItemCfg itemCfg)
        {
            Transform tf = sceneObject.transform.Find("Border/BorderRes");

            // 刷新父节点Border的数据
            tf.parent.position = Vector3.zero;
            tf.parent.eulerAngles = Vector3.zero;
            tf.parent.localScale = Vector3.one;

            string resPath;

            if (itemCfg.Id != ConstItemID.BORDERID)
            {
                resPath = ResPathUtil.GetPhotographBorderPath(itemCfg.Res,
                    ItemUtil.GetItemResExt(itemCfg.ItemType, itemCfg.SubType));
            }
            // 默认无边框不用加载资源
            else
            {
                resPath = "";
            }

            SetSpriteRendererToTransform(tf, resPath);
            SpriteRenderer spr = tf.GetComponent<SpriteRenderer>();
            spr.sortingOrder = 10000; //边框在所有道具的上边
            SetBoxCollider2DToGameObject(tf.gameObject);
        }

        public void AddNpcItem(ItemCfg itemCfg)
        {
            Transform tf = sceneObject.transform.Find("Scene/Npc/NpcRes");
            string resPath = ResPathUtil.GetNpcPicFPath(itemCfg.Res);
            SetSpriteRendererToTransform(tf, resPath);
            SpriteRenderer spr = tf.GetComponent<SpriteRenderer>();
            tf.localPosition = new Vector2(-spr.bounds.center.x, -spr.bounds.center.y);
            SetBoxCollider2DToGameObject(tf.gameObject);
            AddItemGameObjectToList(tf.parent.gameObject, true);
        }

        public void AddBodyItem(int isLeft = 0)
        {
            GameObject bodyParent = sceneObject.transform.Find("Scene/Role").gameObject;

            if (isLeft == 1)
            {
                MatchingLeftDataManager.Instance.roleGameobj = bodyParent;
            }
            else if (isLeft == 2)
            {
                MatchingRightDataManager.Instance.roleGameobj = bodyParent;
            }
            else
            {
                MatchingCompetitionDataManager.Instance.roleGameobj = bodyParent;
                MatchingOneDataManager.Instance.roleGameobj = bodyParent;
            }

            UpdatePhotographBody(sceneObject, bodyParent);
            AddItemGameObjectToList(bodyParent, false);
        }

        public async Task AddSceneItem(GameObject parentGameObj, ItemCfg itemCfg, int layer, bool setLayer,
            bool isOnlyEff = false, int isLeft = 0)
        {
            if (isLeft == 1)
            {
                MatchingLeftDataManager.Instance.itemGameObjs.Add(parentGameObj);
            }
            else if (isLeft == 2)
            {
                MatchingRightDataManager.Instance.itemGameObjs.Add(parentGameObj);
            }
            else
            {
                MatchingCompetitionDataManager.Instance.itemGameObjs.Add(parentGameObj);
                MatchingOneDataManager.Instance.itemGameObjs.Add(parentGameObj);
            }

            await AddItemToScene(sceneObject, parentGameObj, itemCfg.Id, layer);

            //string layerName = string.Format("ResLayer{0}", layer);
            //string value = typeof(ItemCfg).GetField(layerName).GetValue(itemCfg).ToString();

            AddItemGameObjectToList(parentGameObj, setLayer);
        }

        //拍照场景添加单个道具
        public async Task AddItemToScene(GameObject sceneObj, GameObject parentGameObj, int itemId, int resLayer)
        {
            ItemCfg itemCfg = CommonDataManager.Tables.TblItemCfg.GetOrDefault(itemId);
            parentGameObj.transform.SetParent(sceneObj.transform.Find("Scene"), false);


            string layerName = string.Format("ResLayer{0}", resLayer);
            var typeItem = typeof(ItemCfg).GetField(layerName);
            string value = typeItem.GetValue(itemCfg).ToString();
            string res = value == "n" ? itemCfg.Res : string.Format("{0}_{1}", itemCfg.Res, value);

            string resPath = ResPathUtil.GetDressUpAnimationPath(res);
            var handler = DressUpUtil.AddItemAsync(itemId, sceneObj, false, true, parentGameObj, resLayer);
            if (handler != null)
            {
                foreach (var t in handler)
                {
                    await t.Task;
                }

                foreach (var t in handler)
                {
                    t.UpdateView();
                    t.Release();
                }
            }

            if (YooAssetsEx.CheckResExist(resPath))
            {
                parentGameObj.transform.localPosition = Vector3.zero;
            }
            else
            {
                if (parentGameObj.transform.childCount > 0)
                {
                    GameObject gameObject = parentGameObj.transform.GetChild(0).gameObject;
                    SetBoxCollider2DToGameObject(gameObject);
                }
            }

            await PhotographUtil.Instance.SetGameObjectCenter(parentGameObj);
        }

        //拍照角色
        private void UpdatePhotographBody(GameObject sceneObj, GameObject parentObj)
        {
            PhotographDataManager.Instance.dressUpObj.setSceneObj(sceneObj, false, false, parentObj, false,
                async () => { SetRoleBoxCollider(parentObj); });
            PhotographDataManager.Instance.dressUpObj.PutOnDressUpData(MyDressUpHelper.dressUpObj.DressUpDataClone());
        }

        private async void SetRoleBoxCollider(GameObject parentObj)
        {
            for (int i = 0; i < parentObj.transform.childCount; i++)
            {
                Transform transform = parentObj.transform.GetChild(i);
                if (transform.gameObject.GetComponent<SpriteRenderer>() != null)
                {
                    SetBoxCollider2DToGameObject(transform.gameObject);
                }
            }

            await PhotographUtil.Instance.SetGameObjectCenter(parentObj);
        }

        //向Transform添加SpriteRenderer并设置资源
        private void SetSpriteRendererToTransform(Transform tf, string resPath)
        {
            tf.position = Vector3.zero;
            SpriteRenderer spr = tf.GetComponent<SpriteRenderer>();
            if (spr == null)
            {
                tf.gameObject.AddComponent<SpriteRenderer>();
                spr = tf.GetComponent<SpriteRenderer>();
            }

            if (resPath != "")
            {
                SpriteHelper.AddSpriteTo(spr, resPath);
                spr.size = spr.sprite.bounds.size; //将节点设置为原图大小
            }
            else
            {
                spr.sprite = null;
            }
        }

        //向GameObject添加BoxCollider2D
        private void SetBoxCollider2DToGameObject(GameObject gameObject)
        {
            BoxCollider2D polygonCollider2D = gameObject.GetComponent<BoxCollider2D>();
            if (polygonCollider2D != null)
            {
                GameObject.Destroy(polygonCollider2D);
            }

            polygonCollider2D = gameObject.AddComponent<BoxCollider2D>();
            polygonCollider2D.isTrigger = true;
        }

        private void AddItemGameObjectToList(GameObject parentGameObj, bool setLayer)
        {
            List<GameObject> itemGameObjs = PhotographDataManager.Instance.itemGameObjs;
            bool hasSame = false;
            for (int i = 0; i < itemGameObjs.Count; i++)
            {
                if (itemGameObjs[i].name == parentGameObj.name && parentGameObj.name == "Npc")
                {
                    hasSame = true;
                    itemGameObjs[i] = parentGameObj;
                }
                else if (itemGameObjs[i].name == parentGameObj.name && parentGameObj.name == "Border")
                {
                    hasSame = true;
                    itemGameObjs[i] = parentGameObj;
                }
            }

            if (!hasSame)
            {
                itemGameObjs.Add(parentGameObj);
            }

            if (setLayer)
            {
                int index = itemGameObjs.Count - 1;
                PhotographUtil.Instance.ChangeLayer(itemGameObjs[index], index * PhotographDataManager.layerCount,
                    "up");
            }

            itemGameObjs.Sort((GameObject a, GameObject b) =>
            {
                int layerA = PhotographUtil.Instance.GetMaxLayer(a);
                int layerB = PhotographUtil.Instance.GetMaxLayer(b);
                if (layerA < layerB)
                {
                    return -1;
                }
                else if (layerA > layerB)
                {
                    return 1;
                }

                return string.Compare(a.name, b.name);
            });
        }

        private List<GameObject> SortItemGameObjsLayer(List<GameObject> itemGameObjs)
        {
            itemGameObjs.Sort((GameObject a, GameObject b) =>
            {
                int layerA = PhotographUtil.Instance.GetMinLayer(a);
                int layerB = PhotographUtil.Instance.GetMinLayer(b);
                if (layerA < layerB)
                {
                    return -1;
                }
                else if (layerA > layerB)
                {
                    return 1;
                }

                return string.Compare(a.name, b.name);
            });
            return itemGameObjs;
        }

        //移除指定GameObject的BoxCollider2D
        public void DeleteBoxCollider2DFromGameObject(GameObject gameObject)
        {
            BoxCollider2D polygonCollider2D = gameObject.GetComponent<BoxCollider2D>();
            if (polygonCollider2D != null)
            {
                GameObject.Destroy(polygonCollider2D);
            }
        }

        //移除指定GameObject的SpriteRenderer
        public void DeleteSpriteRendererFromGameObject(GameObject gameObject)
        {
            SpriteRenderer spriteRenderer = gameObject.GetComponent<SpriteRenderer>();
            if (spriteRenderer != null)
            {
                GameObject.Destroy(spriteRenderer);
            }
        }
    }
}