ylsj/Assets/Scripts/Core/Foundation/DragonBonesManager.cs

using UnityEngine;
using System.Collections;
using System;
using System.Collections.Generic;

/// <summary>
/// 
/// </summary>
public class DragonBonesManager : MonoSingleton<DragonBonesManager>
{

    /// <summary>
    /// 资源
    /// </summary>
    public Dictionary<string, UseDragonBoneRecordVo> loadDBDataRecord = new Dictionary<string, UseDragonBoneRecordVo>();

    /// <summary>
    /// 资源
    /// </summary>
    public Dictionary<string, Texture2D> mIconRes = new Dictionary<string, Texture2D>();

    /// <summary>
    /// 资源
    /// </summary>
    public Dictionary<string, DragonBonesDataVo> mDataRes = new Dictionary<string, DragonBonesDataVo>();

    /// <summary>
    /// 初始化
    /// </summary>
    private void Start()
    {
        loadDBDataRecord.Clear();
        mDataRes.Clear();
        mIconRes.Clear();
    }

    /// <summary>
    /// 卸载
    /// </summary>
    protected void OnDestroy()
    {
    }

    /// <summary>
    /// 加载资源
    /// </summary>
    /// <param name="bundleName"> 资源包的名称 </param>
    /// <param name="ac"> 加载完后执行的回调 </param>
    private void LoadAsset(string bundleName, Action ac)
    {
        ResourceHelper.Instance.LoadAssetBundle(bundleName, (AssetBundle bundle) =>
        {
            if (null != bundle)
            {
                GameObject go = (GameObject)bundle.LoadAsset(bundleName);
                string textureResName = bundleName + "_tex";

                DragonBonesDataVo vo = new DragonBonesDataVo();
                vo.mSkeletonJson = (TextAsset)bundle.LoadAsset(bundleName + "_ske", typeof(TextAsset));
                vo.mTextureJson = (TextAsset)bundle.LoadAsset(bundleName + "_tex", typeof(TextAsset));
                mDataRes[bundleName] = vo;

                UnityEngine.Object[] sprObj = bundle.LoadAllAssets(typeof(Texture2D));
                foreach (UnityEngine.Object element in sprObj)
                {
                    if (element.name == textureResName)
                    {
                        Texture2D ogr = element as Texture2D;

                        mIconRes[textureResName] = ogr;

                        break;
                    }
                } ac();
            }
            else
            {
                LogHelper.LogError("不存在..........." + bundleName);
                ac();
            }


        });
    }

    /// <summary>
    ///  请求龙骨的数据
    /// </summary>
    /// <param name="bundleName">"101001_Wun"</param>
    /// <param name="ac"></param>
    public void QueryAsset(string bundleName, Action<DragonBonesDataVo, Texture2D> ac)
    {
        string textureResName = bundleName + "_tex";
        if (loadDBDataRecord.ContainsKey(bundleName))
        {
            UseDragonBoneRecordVo vo = loadDBDataRecord[bundleName];
            vo.lastUseDbDataTs = DateTime.Now.ToUnixTimeStamp();              

            if (mIconRes[textureResName] == null)
            {
                LogHelper.LogError(" Error!!!!QueryAsset::" + bundleName);
            }
            if (ac != null)
            {
                ac(mDataRes[bundleName], mIconRes[textureResName]);
            }
        }
        else
        {
            LoadAsset(bundleName, () =>
            {
                if (loadDBDataRecord.ContainsKey(bundleName))
                {
                    UseDragonBoneRecordVo vo = loadDBDataRecord[bundleName];
                    vo.lastUseDbDataTs = DateTime.Now.ToUnixTimeStamp();
                }
                else
                {
                    UseDragonBoneRecordVo vo = new UseDragonBoneRecordVo();
                    vo.createTs = DateTime.Now.ToUnixTimeStamp();
                    vo.dragonBoneName = bundleName;
                    vo.lastUseDbDataTs = vo.createTs;
                    vo.useDbDataCount = 0;
                    loadDBDataRecord.Add(bundleName, vo);
                }

                if (ac != null)
                {
                    if (!mDataRes.ContainsKey(bundleName))
                    {
                        LogHelper.LogError("drg" + bundleName);
                    }
                    
                    if (!mIconRes.ContainsKey(textureResName))
                    {
                        LogHelper.LogError("icon" + textureResName);
                    }
                    
                    ac(mDataRes[bundleName], mIconRes[textureResName]);
                }
            });
        }
    }
   
    /// <summary>
    /// 清理指定的龙骨bundle
    /// </summary>
    /// <param name="dragonId"></param>
    public void UnloadDragonBoneBundle(string dragonId)
    {
        if (loadDBDataRecord.ContainsKey(dragonId))
        {
            UseDragonBoneRecordVo id2 = loadDBDataRecord[dragonId];
            foreach (GameObject go in id2.createGameObjectList)
            {
                if (go != null)
                {
                    Destroy(go);
                }
            }
            //LogHelper.LogError("～～～卸载龙骨的数据文家啦啦啦～～～" + dragonId + "__数据的使用次数：：" + id2.useDbDataCount);
            ResourceHelper.Instance.UnloadAssetBundle(dragonId);
            loadDBDataRecord.Remove(dragonId);
            DragonBones.UnityFactory.factory.RemoveDragonBonesData(dragonId, true);
            DragonBones.UnityFactory.factory.RemoveTextureAtlasData(dragonId, true);
        }
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="id1"></param>
    /// <param name="id2"></param>
    /// <returns></returns>
    public int SortDB(string key1, string key2)
    {
        int res = 0;
        UseDragonBoneRecordVo id1 = null;
        UseDragonBoneRecordVo id2 = null;

        if (loadDBDataRecord.ContainsKey(key1))
        {
            id1 = loadDBDataRecord[key1];
        }

        if (loadDBDataRecord.ContainsKey(key2))
        {
            id2 = loadDBDataRecord[key2];
        }

        if ((id1 == null) && (id2 == null))
        {
            return 0;
        }
        else if ((id1 != null) && (id2 == null))
        {
            return 1;
        }
        else if ((id1 == null) && (id2 != null))
        {
            return -1;
        }

        if (id1.lastUseDbDataTs > id2.lastUseDbDataTs)
        {
            res = -1;
        }
        else if (id1.lastUseDbDataTs < id2.lastUseDbDataTs)
        {
            res = 1;
        }   
        else
        {
            if (id1.useDbDataCount > id2.useDbDataCount)
            {
                res = -1;
            }
            else if (id1.useDbDataCount < id2.useDbDataCount)
            {
                res = 1;
            }
            else
            {
                if (id1.createTs > id2.createTs)
                {
                    res = -1;
                }
                else if (id1.createTs < id2.createTs)
                {
                    res = 1;
                }
            }
        }

        return res;
    }

}

/// <summary>
/// 龙骨数据使用记录
/// </summary>
public class UseDragonBoneRecordVo
{
    /// <summary>
    /// 创建时间
    /// </summary>
    public uint createTs;

    /// <summary>
    /// 龙骨模型ID
    /// </summary>
    public string dragonBoneName;

   /// <summary>
   /// 最后一次使用的时间
   /// </summary>
   public uint lastUseDbDataTs;

    /// <summary>
    /// 数据模型的使用次数
    /// </summary>
    public uint useDbDataCount;

    /// <summary>
    /// 
    /// </summary>
    public List<GameObject> createGameObjectList=new List<GameObject>();
}

/// <summary>
///  龙骨数据
/// </summary>
public class DragonBonesDataVo
{
    /// <summary>
    /// 资源引用
    /// </summary>
    public TextAsset mSkeletonJson;

    /// <summary>
    /// 图片资源引用
    /// </summary>
    public TextAsset mTextureJson;
}