2016-09-03 12:00:39 PirateCode 阅读数 3923

一、Unity3D工程中使用配置文件一般使用Txt、Xml、Json、Db(数据库),四种格式文件对比:
Txt: 需要自己设定格式、封装读取的方式;一般只读,不做修改(操作麻烦)
Xml:标签语言,有自己的格式,系统提供读取和修改等相关API,操作方便。小游戏可用来存档
Json:采用键值对的方式进行存储,适合任意平台,一般客户端与服务端通讯采用该数据格式,同等数据信息要比Xml文件小,还可以只进行值存储(不需要键),更加缩小了文件的体积,适合在移动端进行联网游戏的通信操作
db: 适合复杂数据和敏感数据,增删该查非常方便

二、在Unity中会把配置文件放入到StreamingAsset中,在该文件下发布不会对该文件夹下的文件进行压缩和加密。在不同平台会有些差异:

PC平台: 可以读写 使用System.IO可以直接操作
Android: 只读 需要使用WWW进行读取,System.IO会读取失败
iOS: 只读
为了适应各平台,最好使用WWW进行文件读取操作,可以适用所有平台。
注意:如果使用db文件,为了能够修改数据,需要在Android和iOS端将db文件转移到Application.persistentDataPath路径下。

三、数据库配置操作:平台不同有差异
Window:
Plugins(文件夹)—->Mon.Data.Sqilite.dll System.Data.dll sqlite3.dll
Android :
Plugins(文件夹)—->Mon.Data.Sqilite.dll System.Data.dll sqlite3.dll
Plugins(文件夹)—>Android(文件夹)—–>libsqlite.so
iOS:
Plugins(文件夹)—->Mon.Data.Sqilite.dll System.Data.dll sqlite3.dll
Plugins(文件夹)—>IOS(文件夹)—–>libsqlite.so

2017-04-08 16:42:13 qq_33747722 阅读数 5889

配置资源文件估计大家了解很多,比如XML、JSON、Protobuf、Excel、TXT等等

在开发过程中,将游戏数据序列化到配置文件中,项目运行时读取配置文件中的数据

本文另外介绍一个Unity的配置文件(.asset)

该配置文件的优点:

当我们需要将游戏资源里的贴图(Texture)、游戏对象(Gameobject)等预设体保存到配置文件时,这时我们就可以使用该配置文件

但是当关联的预设体丢失时,需要重新将预设体关联起来

接下来,我写了一个Demo,介绍在Unity3D创建自定义配置资源文件点击打开链接

【管理类】

创建一个管理类,提供函数来创建和读取配置文件(.asset)

在这里我已经简单的封装好了,大家下载来后直接使用即可

 

using UnityEngine;
using System.Collections;
using System.IO;
using UnityEditor;

public class CustomConfigManager<T> where T : ScriptableObject//对泛型参数进行约束,使其只能是ScriptableObject的派生类
{

    private static CustomConfigManager<T> _instance;

    public static CustomConfigManager<T> GetInstance
    {
        get
        {
            if(_instance==null)
            {
                _instance=new CustomConfigManager<T>();
            }

            return _instance;
        }
    }

    private CustomConfigManager()
    { 
    }

    /// <summary>
    /// 将类实例化为配置文件
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public static void CreateAsset()
    {
        //将对象实例化
        ScriptableObject so = ScriptableObject.CreateInstance(typeof(T));

        if (so == null)
        {
            Debug.Log("该对象无效,无法将对象实例化");
            return;
        }

        //自定义配置资源路径
        string path = Application.dataPath + "/CustomConfigFile/MyFile";

        //判断该路径是否存在,不存在的话创建一个
        if (Directory.Exists(path)==false)
        {
            Directory.CreateDirectory(path);
        }


        //配置文件以.asset结尾
        //将对象名配置成与类名相同
        path = string.Format("Assets/CustomConfigFile/MyFile/{0}.asset",typeof(T).ToString());

        //按指定路径生成配置文件
        AssetDatabase.CreateAsset(so,path);
    }


    /// <summary>
    /// 将配置文件转化为对象
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public static void GetAsset()
    {
        //配置文件名与对象名一致
        string name = typeof(T).ToString();
        string path = string.Format("Assets/CustomConfigFile/MyFile/{0}.asset",name);

        // 将配置文件转化为对象
        T obj = AssetDatabase.LoadAssetAtPath<T>(path);
    }
}

 

 

 

 

 

【创建可序列化类(演示)】

 

using UnityEngine;
using System.Collections;
using System;

public enum MyEnum
{
    START,
    PAUSE
}

/// <summary>
/// 该类可以序列化
/// </summary>
[Serializable]
public class CustomConfig : ScriptableObject//继承ScriptableObject
{
    //需要实例化的变量将其设置为public或者设置其属性为[Serializable]
    public MyEnum me = MyEnum.START;

    public Texture interge;

    [Range(0,10)]
    public float f;

    public GameObject obj;
}

 

 

 

 

 

【测试】

创建一个Editor文件夹,将脚本添加到其中

创建好的管理类后,直接调用即可

 

using UnityEngine;
using System.Collections;
using UnityEditor;

public class MySelfText : MonoBehaviour 
{
    [MenuItem("AssetCreateOrGet/Create")]
    public static void Create()
    {
        CustomConfigManager<CustomConfig>.CreateAsset();
    }

    [MenuItem("AssetCreateOrGet/Get")]
    public static void Get()
    {
        CustomConfigManager<CustomConfig>.GetAsset();
    }
}

 

 

 

 

 

点击按钮,成功创建配置文件

Project视图:

Inspector视图:

 

 

 

 

2017-10-25 17:42:41 leonardo_Davinci 阅读数 2338

一,放置配置文件位置一般放在  StreamingAssets下面


我的TowManager.TxT文件里面写的是

[Tow_Crystal]
#attack=10
#attackDistance=15
#attackInterval=1.5
#weaponName=Test


[Tow_Gatling]
#attack=15
#attackDistance=10
#attackInterval=4
#weaponName=Test


[Tow_Cannon]
#attack=20
#attackDistance=8
#attackInterval=1
#weaponName=Test

具体代码

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

public class Config : MonoBehaviour
{
    //把towDic字典中的内容读取到项目中
    //                    主键                子键     子值
 public  static Dictionary<string, Dictionary<string, string>> towDic =
        new Dictionary<string, Dictionary<string, string>>();
    //按照Dictionary的写法一步一步的写
	// Use this for initialization
 public string path = "TowManager.txt";
//配置文件要放在Awake里面,因为要在项目运行中要保证数据要先有
 void Awake()
 {
 	//把新建的配置文件  TowManager.txt文件放到StreamingAssets目录下,之后用Combine合并路径
     path = Path.Combine(Application.streamingAssetsPath, path);
     //用于读取配置信息到数组里面
     string[] items = File.ReadAllLines(path);

     //主键
     string mainKey = null;
     //子键
     string subKey = null;
     //子值
     string subValue = null;
     foreach (var item in items)
     {
     	//判断读取到的行是否为空
         if (!string.IsNullOrEmpty(item))
         {
                  item.Trim();
                 //如果该字符开始是"["     
                 if (item.StartsWith("["))
                 {
                     //去除不用的字符将其作为字典的主键
                     mainKey = item.Substring(1,
                         item.Length - 2).Trim();
                     towDic.Add(mainKey, new Dictionary<string, string>());
                    print("主键为:" + mainKey);
                     //如果开始的符号是#
                   
                  }
                 //如果该字符串是以“#”开始
                 if (item.StartsWith("#"))
                 {
                     //用=号分割    去除不用的符号  分别赋值给子键和子值
                     string[] main = item.Split('=');
                     subKey = (main[0].Substring(1, main[0].Length-1)).Trim();
                     subValue = main[1].Trim();
                     //给主键添加子建和子值
                     towDic[mainKey].Add(subKey, subValue);
                     print("子键为:" + subKey + "    子值为:" + subValue);
                 }
             }
         }
        
     //测试输出是否正确
     print(towDic["Tow_Crystal"]["attack"]);
 }
}

读取配置文件

实例:给你的游戏物体配置相关的值

public abstract class TowState : MonoBehaviour {
    //攻击力
    //    [HideInInspector]
    public float attack;
    //攻击距离
    //    [HideInInspector]
    public float attackDistance;
    //攻击间隔
    public float attackInterval;

    public void Start()
    {
        //主键
        //由于我创建的游戏物体是 Instantiate()实例化出来的因此在获取  主键  要去掉 (Clone)这几个字符(transform.parent.parent.name.Length-7),才能保证主键的一致
        //注意:在游戏场景中不能有这个物体,不然由于场景中的 游戏物体的名称 就是字典中的主键,会报 主键错误(没有匹配到)
        string MainKey=transform.parent.parent.name.Substring(0,transform.parent.parent.name.Length-7);
        //通过测试 通过剪切游戏名来判断是否与主键一致 
        print(MainKey); 
        //获得通过子建的key,获取相应的子值--其中(GameMessager.Instance是一个单例) 
        //由于通过字典得到的值是String类型的,转换为float类型
        attack=float.Parse(GameMessager.instance.configFile[MainKey]["attack"]); 
        attackDistance = float.Parse(GameMessager.instance.configFile[MainKey]["attackDistance"]); 
        attackInterval = float.Parse(GameMessager.instance.configFile[MainKey]["attackInterval"]); 
        attackTypechange = GameMessager.instance.configFile[MainKey]["attackType"]; 
    }
}



注意:如有错误,请查看你创建的角色名是否和配置文件中的角色名一致,查看你的角色名通过剪切后是否和字典中相应的主键一致,其他就没有问题了,





2018-03-22 14:46:49 zwg739424406 阅读数 899

一、资源配置文件、序列化的介绍

资源配置文件:在游戏开发中,经常会用到一些配置文件保存一些数据,然后项目运行中读取这些配置文件中的数据在游戏中使用。比如 XML、JSON、Protobuf、Excel、TXT等等。

序列化:就是将数据的状态信息转换为可以存储或传输的形式的过程。比如将游戏里面的数据写进文件里, 包括角色的生命, 攻击, 防御等等. 这样当游戏需要调整时 (比如平衡性问题), 就只需要对文件进行改写, 而不需要将游戏进行重新编译. 玩家在更新的时候也只需要下载几个被改写的文件即可.

1.变量 –> 2.序列化格式数据 –> 3.保存为文件到硬盘 –> 4.加载文件 –> 5.读取序列化格式数据 –> 6.变量
1到2就是序列化,5到6就是反序列化

二、unity的自定义配置文件

接下来说下使用可序列化类保存配置,介绍一个Unity的配置文件(.asset)。
优点:当我们需要将游戏资源里的贴图(Texture)、游戏对象(Gameobject)等预设体保存到配置文件时,这时我们就可以使用该配置文件,但是当关联的预设体丢失时,需要重新将预设体关联起来。

三、通过案例深入理解

下面做一个小案例
1. 玩家通过鼠标点击屏幕创建出不同的对象(玩家通过配置文件自定义),创建出来的对象通过资源池进行管理
2. 每个类都有详细介绍,可以根据需求直接使用

创建序列化类资源池类【GameObjectPool】– 存储游戏资源
1. 该类声明为 [Serializable]
2. 需要序列化的变量将其设置为public或者设置其属性为[SerializeField]

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

[Serializable]
public class GameObjectPool {
    [SerializeField]
    private string m_name;
    [SerializeField]
    private GameObject m_perfab;
    [SerializeField]
    private int m_maxAmount;

    public string name
    {
        get
        {
            return m_name;
        }
    }
    public GameObject gameobject
    {
        get
        {
            return m_perfab;
        }
    }
    public int maxAmount
    {
        get
        {
            return m_maxAmount;
        }
    }

    //
    [NonSerialized]
    private List<GameObject> m_gameObjList = new List<GameObject>();
    public List<GameObject> gameObjList
    {
        get
        {
            if(m_gameObjList == null)
            {
                m_gameObjList = new List<GameObject>();
            }
            return m_gameObjList;
        }
    }

    //如果要优化,可以在创建一个list用来存放Active为false的物体,需要的时候直接获取就不用遍历了
    public GameObject GetObject()
    {
        foreach(GameObject obj in m_gameObjList)
        {
            if (!obj.activeInHierarchy)
            {
                obj.SetActive(true);
                return obj;
            }
        }
        if(m_gameObjList.Count >= m_maxAmount)
        {
            GameObject.Destroy(m_gameObjList[0]);
            m_gameObjList.RemoveAt(0);
        }

        GameObject prefab = GameObject.Instantiate(m_perfab, new Vector3(0, 3, 0), Quaternion.identity);
        m_gameObjList.Add(prefab);
        return prefab;
    }
}

存储所有资源池的类【GameObjectPoolList】 – 创建该类为配置文件
1. 类必须继承 ScriptableObject

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

/// <summary>
/// 存储所有的资源池  继承ScriptableObject变成可自定义的资源配置文件
/// </summary>
public class GameObjectPoolList: ScriptableObject
{
    [SerializeField]
    private List<GameObjectPool> m_poolList = new List<GameObjectPool>();
    public List<GameObjectPool> poolList
    {
        get
        {
            if(m_poolList == null)
            {
                m_poolList = new List<GameObjectPool>();
            }
            return m_poolList;
        }
    }
}

管理资源池的类【PoolManager】 – 外界通过访问这个类来访问资源池

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

public class PoolManager {

    private static PoolManager m_instance = null;
    public static PoolManager Instance
    {
        get
        {
            if(m_instance == null)
            {
                m_instance = new PoolManager();
            }
            return m_instance;
        }
    }

    //文件路径
    private const string m_pathPrefix = "Assets/FrameWork/Resources/";
    private const string m_fileName = "Gameobjectpool";
    private const string m_pathPostfix = ".asset";
    public static string PoolConfigPath
    {
        get
        {
            return m_pathPrefix + m_fileName + m_pathPostfix;
        }
    }
    //字典  根据name查找对应的pool
    private Dictionary<string, GameObjectPool> m_poolDic;

    //构造函数
    PoolManager()
    {
        GameObjectPoolList poolList = Resources.Load<GameObjectPoolList>(m_fileName);//获取文件类

        m_poolDic = new Dictionary<string, GameObjectPool>();
        foreach(GameObjectPool pool in poolList.poolList)
        {
            m_poolDic.Add(pool.name, pool);
        }
    }

    public void Init()
    {
        //do nothing
    }

    public GameObject GetObjectFromPool(string poolName)
    {
        GameObjectPool pool;
        if(m_poolDic.TryGetValue(poolName, out pool))
        {
            return pool.GetObject();
        }
        else
        {
            Debug.LogWarning("poolName: " + poolName + "  is not exit");
            return null;
        }
    }
}

创建配置文件的类 【PoolManagerEditor】– 利用编译器方法创建 GameObjectPoolList 为配置文件
1. 工程下新建一个文件夹 Editor,在该文件夹下创建下面的类
2. 菜单栏中找 Manager –> Create GameObjectPoolConfig 点击运行就可以 PoolManager.PoolConfigPath 的路径下看到生成的配置文件

public class PoolManagerEditor
{
    //将这个方法做成一个菜单
    [MenuItem("Manager/Create GameObjectPoolConfig")]
    static void CreatePoolList()
    {
        //将对象实例化
        GameObjectPoolList poolList = ScriptableObject.CreateInstance<GameObjectPoolList>();

        //创建类为可编辑的配置文件
        AssetDatabase.CreateAsset(poolList, PoolManager.PoolConfigPath);
        AssetDatabase.SaveAssets();
    }
}

四、测试

1. 通过配置文件,自行配置资源
这里写图片描述

2. 代码测试

private void Update()
{
   if (Input.GetMouseButtonDown(0))
   {
      GameObject obj = PoolManager.Instance.GetObjectFromPool("Sphere");
   }
}
2016-01-21 21:27:06 youke363 阅读数 1192

xlsxtools游戏配置表工具,开源跨平台,支持多语言。Unity3D等游戏引擎使用Excel做游戏配置表的解决方案,将xlsx文件转换成txt文本文件,并生成解析代码的工具。已支持C#,Java,OC,即将支持C/C++等。

一、开源地址

1.git oschina地址:https://git.oschina.net/youke/xlsxtools.git

二、简介

  1.xlsxtools是一个将xlsx文件转换成txt文本文件,并生成解析代码的工具

  2.xlsxtools使用python脚本开发,能快速实现跨平台功能

  3.目前支持生成C#,Java语言,C/C++/OC正在开发中

  4.结合Jenkins与SVN,就可以实现一键转化与自动同步Unity3D,方便,实用,靠谱。

三、参与人员

星仔(QQ:197279437),卡哇(QQ:240886393)

四、xlsxtools环境搭建 1.安装Python,推荐使用2.7.10

2.安装Python插件setuptools

    a.xlsxtools/zip目录下,推荐setuptools-7.0.zip

    b.执行sudo python setup.py install

3.安装Python插件openpyxl

    a. xlsxtools/zip目录下,推荐openpyxl_1.7.0.zip

    b.执行sudo python setup.py install

五、详细使用过程,参考README.docx

Unity3D之文件读写

阅读数 289

没有更多推荐了,返回首页