Unity resource and txt document management framework

 ResourceAndDataManager provides methods to obtain resources and text content through PrefabLoad and TxtDataLoad.

ResourceAndDataManager

using UnityEngine;

public class ResourceAndDataManager
{
    #region singleton
    
    private static ResourceAndDataManager instance;

    public static ResourceAndDataManager Instance
    {
        get
        {
            if (instance == null)
            {
                instance = new ResourceAndDataManager();
            }

            return instance;
        }
    }
    
    #endregion

    /// <summary>
    /// 读取txt文件对象
    /// </summary>
    private TxtDataLoad txtDataLoad;

    /// <summary>
    /// 加载Prefab文件
    /// </summary>
    private PrefabLoad prefabLoad;

    private ResourceAndDataManager()
    {
        txtDataLoad = new TxtDataLoad();
        prefabLoad = new PrefabLoad();
    }

    #region 获取assetbundle路径
    
    /// <summary>
    /// 获取Assetbundle自动打包目录
    /// </summary>
    /// <returns></returns>
    public string ObtainAssetbundleReadPath()
    {
        return txtDataLoad.ObtainAssetbundleReadPath();
    }
    
    /// <summary>
    /// 获取Assetbundle自动保存目录
    /// </summary>
    /// <returns></returns>
    public string ObtainAssetbundleWritePath()
    {
        return txtDataLoad.ObtainAssetbundleWritePath();
    }
    
    #endregion

    #region Obtain Parameter

    /// <summary>
    /// 获取玩家参数
    /// </summary>
    /// <param name="contentName">参数名称</param>
    /// <returns></returns>
    public string ObtainPlayerParameter(string parameterName)
    {
        return txtDataLoad.ObtainPlayerParameter(parameterName);
    }

    /// <summary>
    /// 获取敌人参数
    /// </summary>
    /// <param name="parameterName"></param>
    /// <returns></returns>
    public string ObtainEnemyParameter(string parameterName)
    {
        return txtDataLoad.ObtainEnemyParameter(parameterName);
    }

    /// <summary>
    /// 获取摄像机参数
    /// </summary>
    /// <param name="parameterName"></param>
    /// <returns></returns>
    public string ObtainCameraParameter(string parameterName)
    {
        return txtDataLoad.ObtainCameraParameter(parameterName);
    }

    /// <summary>
    /// 获取其它参数
    /// </summary>
    /// <param name="parameterName"></param>
    /// <returns></returns>
    public string ObtainOtherParameter(string parameterName)
    {
        return txtDataLoad.ObtainOtherParameter(parameterName);
    }

    /// <summary>
    /// 获取技能数据模型
    /// </summary>
    /// <param name="skillName"></param>
    /// <returns></returns>
    public SkillModel ObtainSkillModel(string skillName)
    {
        return txtDataLoad.ObtainSkillModel(skillName);
    }

    #region Article

    /// <summary>
    /// 获取加血草数据模型
    /// </summary>
    /// <returns></returns>
    public AddBloodArticleModel ObtainArticleByHPHerbal()
    {
        return txtDataLoad.ObtainArticleByHPHerbal();
    }

    /// <summary>
    /// 获取加蓝草数据模型
    /// </summary>
    /// <returns></returns>
    public AddMagicArticleModel ObtainArticleByMPHerbal()
    {
        return txtDataLoad.ObtainArticleByMPHerbal();
    }

    #endregion

    #endregion

    /// <summary>
    /// 获取Sprite图片资源
    /// </summary>
    /// <param name="imageName"></param>
    /// <returns></returns>
    public Sprite ObtainImage(string imageName)
    {
        Texture2D texture2D = prefabLoad.LoadAssetBundleByFile(imageName, imageName) as Texture2D;

        float width = texture2D.width;
        float height = texture2D.height;

        Sprite sprite = Sprite.Create(texture2D, new Rect(0, 0, width, height), Vector2.zero);
        
        prefabLoad.UnloadResource();

        return sprite;
    }
    
    /// <summary>
    /// 获取Sprite图片资源
    /// </summary>
    /// <param name="imageName"> 需要加载的文件名称（如果有重复需要加上相对路径） </param>
    /// <param name="assetBundleName"> 需要解压的 assetBundle 的名称 </param>
    /// <returns></returns>
    public Sprite ObtainImage(string imageName, string assetBundleName)
    {
        Texture2D texture2D = prefabLoad.LoadAssetBundleByFile(imageName, assetBundleName) as Texture2D;

        float width = texture2D.width;
        float height = texture2D.height;

        Sprite sprite = Sprite.Create(texture2D, new Rect(0, 0, width, height), Vector2.zero);
        
        prefabLoad.UnloadResource();

        return sprite;
    }

    /// <summary>
    /// 获取 AudioClip 资源
    /// </summary>
    /// <param name="audioName"></param>
    /// <returns></returns>
    public AudioClip ObtainAudioClip(string audioName)
    {
        AudioClip audioClip = prefabLoad.LoadAssetBundleByFile(audioName, audioName) as AudioClip;
        
        prefabLoad.UnloadResource();

        return audioClip;
    }

    /// <summary>
    /// 获取生成预制件
    /// </summary>
    /// <param name="prefabName"></param>
    /// <returns></returns>
    public GameObject ObtainPrefab(string prefabName)
    {
        GameObject prefab = prefabLoad.LoadAssetBundleByFile(prefabName, prefabName) as GameObject;
        
        prefabLoad.UnloadResource();

        return prefab;
    }
}

PrefabLoad

Load assetbundle resources.

using UnityEngine;

public class PrefabLoad
{
    /// <summary>
    /// 需要加载的资源路径
    /// </summary>
    private string loadAssetBundlePath;

    /// <summary>
    /// 需要加载的资源路径
    /// </summary>
    public string LoadAssetBundlePath
    {
        get
        {
            return ResourceAndDataManager.Instance.ObtainAssetbundleWritePath();
        }
    }

    /// <summary>
    /// 资源列表说明文件
    /// </summary>
    private string manifestName;

    /// <summary>
    /// 资源列表说明文件的全路径
    /// </summary>
    private string manifestFullName;
    
    /// <summary>
    /// 加载的资源
    /// </summary>
    private AssetBundle realAssetBundle;

    /// <summary>
    /// 实例化资源依赖的AssetBundle数组
    /// </summary>
    private AssetBundle[] dependenciesBundles;
    
    /// <summary>
    /// 加载资源到内存
    /// </summary>
    /// <param name="loadFileName">需要加载的文件名称</param>
    /// <param name="loadAssetBundleName">需要加载的AssetBundle文件名称</param>
    /// <returns></returns>
    public Object LoadAssetBundleByFile(string loadFileName, string loadAssetBundleName)
    {
        // 拿到资源所在文件的名称
        if (LoadAssetBundlePath.Contains("/"))
        {
            manifestName = LoadAssetBundlePath.Substring(LoadAssetBundlePath.LastIndexOf('/') + 1);
        }
        else
        {
            manifestName = LoadAssetBundlePath;
        }
        
        // 获取资源列表说明文件的全路径
        manifestFullName = Application.streamingAssetsPath + "/" + LoadAssetBundlePath + "/" + manifestName;

        #region 通过AssetBundleManifest加载依赖

        // 加载Manifest文件Bundle
        AssetBundle manifestBundle = AssetBundle.LoadFromFile(manifestFullName);
        
        // 加载真正的Manifest文件
        AssetBundleManifest bundleManifest = manifestBundle.LoadAsset<AssetBundleManifest>("AssetBundleManifest");
        
        // 获取要加载资源的所有依赖名称
        string[] dependencies = bundleManifest.GetAllDependencies(loadAssetBundleName);
        
        // 卸载manifestBundle
        manifestBundle.Unload(true);

        #endregion

        #region 通过AssetDatabase.GetAssetBundleDependencies(loadAssetBundleName, true);加载依赖

        // 获取要加载资源的所有依赖名称
        // string[] dependencies = AssetDatabase.GetAssetBundleDependencies(loadAssetBundleName, true);

        #endregion
        
        // 实例化资源依赖的AssetBundle数组
        dependenciesBundles = new AssetBundle[dependencies.Length];
        
        // 加载所有资源依赖
        for (int i = 0; i < dependencies.Length; i++)
        {
            // 合成依赖路径
            string dependenciesPath = Application.streamingAssetsPath + "/" + LoadAssetBundlePath + "/" + dependencies[i];
            
            // 加载依赖
            AssetBundle dependency = AssetBundle.LoadFromFile(dependenciesPath);
            
            // 存储依赖
            dependenciesBundles[i] = dependency;
        }
        
        // 合成资源路径
        string realAssetBundlePath = Application.streamingAssetsPath + "/" + LoadAssetBundlePath + "/" + loadAssetBundleName;
        
        // 加载的资源
        realAssetBundle = AssetBundle.LoadFromFile(realAssetBundlePath);
        
        // 加载到内存
        Object prefab = realAssetBundle.LoadAsset(loadFileName);

        return prefab;
    }

    /// <summary>
    /// 卸载资源和依赖
    /// </summary>
    public void UnloadResource()
    {
        // 卸载资源和依赖
        realAssetBundle.Unload(false);
        
        for (int i = 0; i < dependenciesBundles.Length; i++)
        {
            dependenciesBundles[i].Unload(false);
        }
    }
}

TxtDataLoad

Read the content of the txt file.

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

public class TxtDataLoad
{
    /// <summary>
    /// AssetBundle路径
    /// </summary>
    private Dictionary<string, string> assetBundlePath;
    
    /// <summary>
    /// 玩家参数
    /// </summary>
    private Dictionary<string, string> playerParameter;

    /// <summary>
    /// 敌人参数
    /// </summary>
    private Dictionary<string, string> enemyParameter;

    /// <summary>
    /// 摄像机参数
    /// </summary>
    private Dictionary<string, string> cameraParameter;

    /// <summary>
    /// 其它参数
    /// </summary>
    private Dictionary<string, string> otherParameter;

    public TxtDataLoad()
    {
        Initial();
    }

    /// <summary>
    /// 初始化
    /// </summary>
    private void Initial()
    {
        assetBundlePath = new Dictionary<string, string>();
        
        LoadText("AssetBundlePath.txt", assetBundlePath);
    }

    /// <summary>
    /// 获取玩家参数
    /// </summary>
    /// <param name="parameterName">参数名称</param>
    /// <returns></returns>
    public string ObtainPlayerParameter(string parameterName)
    {
        if (playerParameter == null)
        {
            playerParameter = new Dictionary<string, string>();
        }
        
        if (playerParameter.ContainsKey(parameterName))
        {
            return playerParameter[parameterName];
        }

        LoadText("PlayerParameter.txt", playerParameter);
        
        return playerParameter[parameterName];
    }

    /// <summary>
    /// 获取敌人参数
    /// </summary>
    /// <param name="parameterName"></param>
    /// <returns></returns>
    public string ObtainEnemyParameter(string parameterName)
    {
        if (enemyParameter == null)
        {
            enemyParameter = new Dictionary<string, string>();
        }

        if (enemyParameter.ContainsKey(parameterName))
        {
            return enemyParameter[parameterName];
        }

        LoadText("EnemyParameter.txt", enemyParameter);

        return enemyParameter[parameterName];
    }

    /// <summary>
    /// 获取摄像机参数
    /// </summary>
    /// <param name="parameterName"></param>
    /// <returns></returns>
    public string ObtainCameraParameter(string parameterName)
    {
        if (cameraParameter == null)
        {
            cameraParameter = new Dictionary<string, string>();
        }
        
        if (cameraParameter.ContainsKey(parameterName))
        {
            return cameraParameter[parameterName];
        }

        LoadText("CameraParameter.txt", cameraParameter);

        return cameraParameter[parameterName];
    }

    /// <summary>
    /// 获取其它参数
    /// </summary>
    /// <param name="parameterName"></param>
    /// <returns></returns>
    public string ObtainOtherParameter(string parameterName)
    {
        if (otherParameter == null)
        {
            otherParameter = new Dictionary<string, string>();
        }

        if (otherParameter.ContainsKey(parameterName))
        {
            return otherParameter[parameterName];
        }

        LoadText("OtherParameter.txt", otherParameter);

        return otherParameter[parameterName];
    }

    /// <summary>
    /// 获取技能数据模型
    /// </summary>
    /// <param name="skillPatn"></param>
    /// <returns></returns>
    public SkillModel ObtainSkillModel(string skillName)
    {
        Dictionary<string, string> skillParameter = new Dictionary<string, string>();

        LoadText("Skills/" + skillName + ".txt", skillParameter);

        SkillModel skillModel = new SkillModel();
        skillModel.skillName = skillParameter["SkillName"];
        skillModel.price = int.Parse(skillParameter["Cost"]);
        skillModel.attackPower = float.Parse(skillParameter["AttackPower"]);
        skillModel.magicConsumption = float.Parse(skillParameter["MagicConsumption"]);
        skillModel.cd = float.Parse(skillParameter["CD"]);
        skillModel.describe = skillParameter["Describe"];

        return skillModel;
    }

    #region Article

    /// <summary>
    /// 获取加血草数据模型
    /// </summary>
    /// <returns></returns>
    public AddBloodArticleModel ObtainArticleByHPHerbal()
    {
        Dictionary<string, string> hpHerbal = new Dictionary<string, string>();

        LoadText("Articles/HPHerbal.txt", hpHerbal);

        AddBloodArticleModel articleModel = new AddBloodArticleModel();
        articleModel.iconName = hpHerbal["IconName"];
        articleModel.duration = float.Parse(hpHerbal["Duration"]);
        articleModel.addBloodVolumeByFirst = float.Parse(hpHerbal["BloodFirst"]);
        articleModel.addBloodVolumeByContinue = float.Parse(hpHerbal["BloodContinue"]);
        articleModel.addBloodIntervalTime = float.Parse(hpHerbal["IntervalTime"]);
        articleModel.describe = hpHerbal["Describe"];

        return articleModel;
    }
    
    /// <summary>
    /// 获取加蓝草数据模型
    /// </summary>
    /// <returns></returns>
    public AddMagicArticleModel ObtainArticleByMPHerbal()
    {
        Dictionary<string, string> mpHerbal = new Dictionary<string, string>();

        LoadText("Articles/MPHerbal.txt", mpHerbal);

        AddMagicArticleModel articleModel = new AddMagicArticleModel();
        articleModel.iconName = mpHerbal["IconName"];
        articleModel.duration = float.Parse(mpHerbal["Duration"]);
        articleModel.addMagicVolumeByFirst = float.Parse(mpHerbal["MagicFirst"]);
        articleModel.addMagicVolumeByContinue = float.Parse(mpHerbal["MagicContinue"]);
        articleModel.addMagicIntervalTime = float.Parse(mpHerbal["IntervalTime"]);
        articleModel.describe = mpHerbal["Describe"];

        return articleModel;
    }

    #endregion
    
    /// <summary>
    /// 读取Txt数据
    /// </summary>
    /// <param name="path"></param>
    /// <param name="dic"></param>
    private void LoadText(string path, Dictionary<string,string> dic)
    {
        string fullPath = Application.streamingAssetsPath + "/" + path;

        // 创建文件流
        FileStream fs = new FileStream(fullPath, FileMode.Open, FileAccess.Read);
        
        // 创建流读取对象
        StreamReader sr = new StreamReader(fs);

        // 读取第一行【接下来要读取几条数据】
        string lineCount = sr.ReadLine();

        for (int i = 0; i < Int32.Parse(lineCount); i++)
        {
            string lineData = sr.ReadLine();
            string[] result = lineData.Split('|');

            dic.Add(result[0], result[1]);
        }
        
        // 释放资源
        if (sr != null)
        {
            sr.Close();
        }

        if (fs != null)
        {
            fs.Close();
        }
    }

    /// <summary>
    /// 获取Assetbundle自动打包目录
    /// </summary>
    /// <returns></returns>
    public string ObtainAssetbundleReadPath()
    {
        return assetBundlePath["Source"];
    }

    /// <summary>
    /// 获取Assetbundle自动保存目录
    /// </summary>
    /// <returns></returns>
    public string ObtainAssetbundleWritePath()
    {
        return assetBundlePath["Place"];
    }
}