Game Of Honor
点击展开
Unity工具
布NPC和怪物编辑器
点击展开
UI动画编辑器
点击展开
Python工具
C#工程配置导表工具
项目工具
点击展开
演示视频
工具截图
博客工具
点击展开
在Unity开发中，我们经常需要将一些数据存储在本地，以便在游戏或应用程序的不同运行周期中使用。虽然Unity提供了PlayerPrefs来满足这个需求，但是PlayerPrefs有一些限制，例如数据类型的限制，以及存储容量的限制。因此，我开发了一种新的本地存储结构，它使用Json文件来存储数据，既可以存储全局信息，也可以存储每个账户的个人信息。此外，这种结构还支持对Json文件进行加密，以保护用户的数据安全。
这种结构允许存储全局信息和每个账户的个人信息。这对于需要在设备上保存用户特定数据的游戏或应用程序非常有用。
所有的数据都存储在一个Json文件中，这使得数据的读取和写入变得非常方便。同时，由于Json是一种轻量级的数据交换格式，所以这种存储方式也非常高效。
为了保护用户的数据安全，这种结构还支持对Json文件进行加密。这样，即使有人能够访问到存储文件，也无法读取其中的内容。
注: 在使用这种存储结构时，你需要注意的是，你需要将Json的序列化和反序列化替换成你自己的接口。此外，这种结构使用了RijndaelManaged进行文件加密，你可能需要根据你的实际需求来调整加密算法。
public static class DataStorage{ private const string kStorageFilename = "storage.json"; private const string kVersion = "version"; private static Hashtable s_Root = new Hashtable(); private static Hashtable s_Current; private static bool s_Refresh = false; private static bool s_IsInit = false;#if USE_ENCRYPT private static RijndaelManaged m_Managed; private static ICryptoTransform m_Encryptor; private static ICryptoTransform m_Decryptor;#endif #region 加载、保存 /// <summary> /// 初始化数据 /// </summary> public static void Init() { var path = GetPath();#if USE_ENCRYPT m_Managed = new RijndaelManaged { Key = Encoding.UTF8.GetBytes("sd@#^%&*^&?*68(7hK%&fd"), IV = Encoding.UTF8.GetBytes("^%&*^&?*682K$d"), Mode = CipherMode.CBC, Padding = PaddingMode.Zeros }; m_Encryptor = m_Managed.CreateEncryptor(); m_Decryptor = m_Managed.CreateDecryptor();#endif if (File.Exists(path)) { try {#if USE_ENCRYPT var bytes = File.ReadAllBytes(path); var data = m_Decryptor.TransformFinalBlock(bytes, 0, bytes.Length);#else var data = File.ReadAllBytes(path);#endif s_Root = JsonUtils.ToHashtable(data); } catch (Exception e) { File.Delete(path); AddNewData(); } } else { AddNewData(); } s_Current = s_Root; s_IsInit = true; } /// <summary> /// 增加新的数据 /// </summary> public static void AddNewData() { s_Root[kVersion] = "1.0.0"; } /// <summary> /// 更新数据 /// </summary> public static void Update() { if (!s_IsInit) return; if (s_Refresh) { s_Refresh = false; Save(); } } /// <summary> /// 卸载数据 /// </summary> public static void UnInit() { s_IsInit = false; if (s_Refresh) { s_Refresh = false; Save(); } } /// <summary> /// 保存数据 /// </summary> private static void Save() { if (!s_IsInit) return; var path = GetPath(); PathUtils.MakeDirectory(path);#if USE_ENCRYPT var bytes = JsonUtils.ToBytes(s_Root); var data = m_Encryptor.TransformFinalBlock(bytes, 0, bytes.Length);#else var data = JsonUtils.ToBytes(s_Root);#endif File.WriteAllBytes(path, data); } /// <summary> /// 获取文件地址(存储文件存放的地址) /// </summary> /// <returns></returns> private static string GetPath() { return PathUtils.GetExternalPath(kStorageFilename); } #endregion #region 增删改查 /// <summary> /// 设置数据（如果数据是默认值就会被移除掉） /// </summary> /// <param name="table"></param> /// <param name="primaryKey"></param> /// <param name="target"></param> /// <typeparam name="T"></typeparam> private static void Set<T>(Hashtable table, string primaryKey, T target) where T : IEquatable<T> { if (null == target || target.Equals(default)) { table.Remove(primaryKey); } else if (table.ContainsKey(primaryKey)) { table[primaryKey] = target; } else { table.Add(primaryKey, target); } s_Refresh = true; } /// <summary> /// 强制设置数据 /// </summary> /// <param name="table"></param> /// <param name="primaryKey"></param> /// <param name="target"></param> /// <typeparam name="T"></typeparam> private static void SetForce<T>(Hashtable table, string primaryKey, T target) where T : IEquatable<T> { if (table.ContainsKey(primaryKey)) { table[primaryKey] = target; } else { table.Add(primaryKey, target); } s_Refresh = true; } /// <summary> /// 读取数据 /// </summary> /// <param name="table"></param> /// <param name="primaryKey"></param> /// <typeparam name="T"></typeparam> /// <returns></returns> private static T Get<T>(Hashtable table, string primaryKey) { if (table.ContainsKey(primaryKey)) { return (T)Convert.ChangeType(table[primaryKey], typeof(T)); } if(table == s_Root && PlayerPrefs.HasKey(primaryKey)) { switch (Type.GetTypeCode(typeof(T))) { case TypeCode.Int32: return (T)Convert.ChangeType(PlayerPrefs.GetInt(primaryKey), typeof(T)); case TypeCode.Single: return (T)Convert.ChangeType(PlayerPrefs.GetFloat(primaryKey), typeof(T)); case TypeCode.String: return (T)Convert.ChangeType(PlayerPrefs.GetString(primaryKey), typeof(T)); case TypeCode.Boolean: return (T)Convert.ChangeType(PlayerPrefs.GetInt(primaryKey) == 1, typeof(T)); default: Logging.Error($"SetRoot {primaryKey} failed, type {typeof(T)} not support."); break; } } return default; } /// <summary> /// 读取数据 /// </summary> /// <param name="primaryKey"></param> /// <typeparam name="T"></typeparam> /// <returns></returns> public static T Get<T>(string primaryKey) { Logging.Assert(s_Current != s_Root, $"get {primaryKey} must after call Enter(..)"); return Get<T>(s_Current, primaryKey); } /// <summary> /// 设置根目录数据 /// </summary> /// <param name="primaryKey"></param> /// <param name="target"></param> /// <param name="isForce"></param> /// <typeparam name="T"></typeparam> public static void SetRoot<T>(string primaryKey, T target, bool isForce = false) where T : IEquatable<T> { if (s_IsInit) { if (isForce) { SetForce(s_Root, primaryKey, target); } else { Set(s_Root, primaryKey, target); } } else { // 根据T的类型使用PlayerPrefs进行保存 switch (Type.GetTypeCode(typeof(T))) { case TypeCode.Int32: PlayerPrefs.SetInt(primaryKey, Convert.ToInt32(target)); break; case TypeCode.Single: PlayerPrefs.SetFloat(primaryKey, Convert.ToSingle(target)); break; case TypeCode.String: PlayerPrefs.SetString(primaryKey, Convert.ToString(target)); break; case TypeCode.Boolean: PlayerPrefs.SetInt(primaryKey, Convert.ToBoolean(target) ? 1 : 0); break; default: Logging.Error($"SetRoot {primaryKey} failed, type {typeof(T)} not support."); break; } } } /// <summary> /// 设置当前用户数据数据 /// </summary> /// <param name="primaryKey"></param> /// <param name="target"></param> /// <param name="isForce"></param> /// <typeparam name="T"></typeparam> public static void Set<T>(string primaryKey, T target, bool isForce = false) where T : IEquatable<T> { Logging.Assert(s_Current != s_Root, $"set {primaryKey} must after call Enter(..)"); if (isForce) { SetForce(s_Current, primaryKey, target); } else { Set(s_Current, primaryKey, target); } } /// <summary> /// 设置根目录数据(含两个关键字的查找) /// </summary> /// <param name="primaryKey"></param> /// <param name="secondaryKey"></param> /// <param name="target"></param> /// <param name="isForce"></param> /// <typeparam name="T"></typeparam> public static void SetRoot<T>(string primaryKey, string secondaryKey, T target, bool isForce = false) where T : IEquatable<T> { Hashtable hashtable; if (s_Root.ContainsKey(primaryKey)) { hashtable = (Hashtable)s_Root[primaryKey]; } else { hashtable = new Hashtable(); s_Root.Add( primaryKey, hashtable); } if (isForce) { SetForce(hashtable, secondaryKey, target); } else { Set(hashtable, secondaryKey, target); } } /// <summary> /// 获取根目录数据 /// </summary> /// <param name="primaryKey"></param> /// <typeparam name="T"></typeparam> /// <returns></returns> public static T GetRoot<T>(string primaryKey) { return Get<T>(s_Root, primaryKey); } /// <summary> /// 获取根目录数据 /// </summary> /// <param name="primaryKey"></param> /// <param name="secondaryKey"></param> /// <typeparam name="T"></typeparam> /// <returns></returns> public static T GetRoot<T>(string primaryKey, string secondaryKey) { return s_Root.ContainsKey(primaryKey) ? Get<T>((Hashtable)s_Root[primaryKey], secondaryKey) : default; } /// <summary> /// 判断是否包含数据 /// </summary> /// <param name="primaryKey"></param> /// <param name="isRoot"></param> /// <returns></returns> public static bool ContainsKey(string primaryKey, bool isRoot = false) { return isRoot ? s_Root.ContainsKey(primaryKey) || PlayerPrefs.HasKey(primaryKey) : s_Current.ContainsKey(primaryKey); } /// <summary> /// 进入当前用户数据(用于多角色存储不同用户数据) /// </summary> /// <param name="primaryKey"></param> public static void Enter(string primaryKey) { Debug.Log("primaryKey = "+ primaryKey); if (s_Current.ContainsKey(primaryKey)) { s_Current = (Hashtable)s_Current[primaryKey]; } else { var hashtable = new Hashtable(); s_Current.Add( primaryKey, hashtable); s_Current = hashtable; } s_Refresh = true; } #endregion}这种新的本地存储结构提供了一种更灵活、更安全的方式来存储和管理本地数据。如果你在使用Unity进行开发，并且需要一种更好的本地存储方案，那么你可以尝试使用这种结构。
]]>这篇博客主要介绍了一个字节序列类CircularBuffer，它是用于频繁创建Stream数据的循环利用。CircularBuffer类继承自Stream类，并实现了其各种方法，包括读写、查找、设置长度等。
在CircularBuffer类中，主要定义了一些关键的属性，如字节数组、偏移值、开始坐标、结束坐标、长度、当前位置、容量、限制读取长度和标记等。其中，字节数组用于存储数据，偏移值用于定位数据，开始坐标和结束坐标用于定义数据的起始和结束位置，长度表示数据的长度，当前位置表示当前读写的位置，容量表示最大可以存储的数据量，限制读取长度用于限制读取的数据长度，标记用于标记当前对象。
在CircularBuffer类中，还定义了一些方法，如初始化、设置限制读取长度、读取字节、查找字节、设置长度、写入字节、收缩、扩展、开始接收、结束接收、开始发送、结束发送、重置等。这些方法主要用于操作和管理数据。
CircularBuffer类的主要优点是可以有效地管理和操作数据，特别是在需要频繁创建Stream数据的情况下，可以有效地提高性能和效率。同时，CircularBuffer类的设计也非常灵活和通用，可以适应各种不同的应用场景。
总的来说，CircularBuffer类是一个非常实用和高效的字节序列类，值得大家在实际的开发中使用和学习。
public class CircularBuffer : Stream{ /// <summary> /// 字节数组 /// </summary> private byte[] m_Buffer; /// <summary> /// 偏移值 /// </summary> private int m_Offset; // [] /// <summary> /// 开始坐标 /// </summary> private int m_Begin; // [0, m_Capacity) /// <summary> /// 结束坐标 /// </summary> private int m_End; // [0, m_Capacity) /// <summary> /// 长度 /// </summary> private int m_Length; /// <summary> /// 当前位置 /// </summary> private int m_Position; /// <summary> /// 容量 /// </summary> private int m_Capacity; /// <summary> /// 限制读取长度 /// </summary> private int m_LimitReadLength; /// <summary> /// 标记 /// </summary> private string m_Tag; /// <summary> /// 缓存 /// </summary> private byte[] m_Cached = new byte[4]; /// <summary> /// 是否刻度 /// </summary> public override bool CanRead => true; /// <summary> /// 是否可定位 /// </summary> public override bool CanSeek => true; /// <summary> /// 是否可写入 /// </summary> public override bool CanWrite => true; /// <summary> /// 长度 /// </summary> public override long Length => m_Length; /// <summary> /// 当前位置坐标 /// </summary> public override long Position { get => m_Position; set { if (m_Position == value) return; Seek(value, SeekOrigin.Begin); } } /// <summary> /// 容器长度 /// </summary> public int Capacity => m_Capacity; /// <summary> /// 标记 /// </summary> public string Tag => m_Tag; /// <summary> /// 索引读取 /// </summary> /// <param name="index"></param> /// <exception cref="ArgumentOutOfRangeException"></exception> public byte this[int index] { get { if (index < 0 || index >= m_Length) { throw new ArgumentOutOfRangeException($"index {index} length {m_Length}"); } var begin = m_Begin; var end = m_End; if (end > begin) { // 0 m_Begin m_End m_Capacity // |_______|_______|_______| // | // m_Position return m_Buffer[m_Offset + begin + index]; } else { // 0 m_End m_Begin m_Capacity // |_______|_______|_______| // | | // (1) m_Position (2) var blockLen = m_Capacity - begin; return blockLen > index ? //(2) m_Buffer[m_Offset + begin + index] : //(1) m_Buffer[m_Offset + index - blockLen]; } } set { if (index < 0 || index >= m_Length) { throw new ArgumentOutOfRangeException($"index {index} length {m_Length}"); } var begin = m_Begin; var end = m_End; if (end > begin) { // 0 m_Begin m_End m_Capacity // |_______|_______|_______| // | // m_Position m_Buffer[m_Offset + begin + index] = value; } else { // 0 m_End m_Begin m_Capacity // |_______|_______|_______| // | | // (1) m_Position (2) var blockLen = m_Capacity - begin; if (blockLen > index) { //(2) m_Buffer[m_Offset + begin + index] = value; } else { //(1) m_Buffer[m_Offset + index - blockLen] = value; } } } } /// <summary> /// 初始化 /// </summary> /// <param name="tag"></param> /// <param name="capcity"></param> public CircularBuffer(string tag, int capcity) { m_Capacity = capcity; m_Buffer = new byte[m_Capacity]; m_Offset = 0; m_Begin = 0; m_End = 0; m_Length = 0; m_Position = 0; m_Tag = tag; } /// <summary> /// 设置限制读取长度 /// </summary> /// <param name="length"></param> public void SetLimitReadLength(int length) { Trace($"{length}"); m_LimitReadLength = length; } #region Override /// <summary> /// 继承的类必须实现此方法，以便在流中写入字节。 /// </summary> /// <exception cref="NotImplementedException"></exception> public override void Flush() { throw new NotImplementedException(); } /// <summary> /// 打印日志 /// </summary> /// <param name="msg"></param> /// <param name="memberName"></param> /// <param name="lineNum"></param> [Conditional("DEBUG_STREAM_TRACE")] private static void Trace(string msg, [CallerMemberName] string memberName = "", [CallerLineNumber] int lineNum = 0) { //Logging.Log($"{m_Tag} {memberName}:{lineNum}:{Thread.CurrentThread.ManagedThreadId} {m_Begin} {m_End} {m_Position} {m_LimitReadLength} {m_Length}/{m_Capacity} {msg}"); } /// <summary> /// 读取字节未见 /// </summary> /// <param name="buffer"></param> /// <param name="offset"></param> /// <param name="count"></param> /// <returns></returns> /// <exception cref="Exception"></exception> public override int Read(byte[] buffer, int offset, int count) { Trace($"{offset} {count}"); var position = m_Position; var dataLen = (int)Math.Min(count, (0 == m_LimitReadLength ? m_Length : m_LimitReadLength) - position); if (0 == dataLen) return 0; try { var begin = m_Begin; var end = m_End; if (end > begin) { // 0 m_Begin m_End m_Capacity // |_______|_______|_______| // | // m_Position Buffer.BlockCopy(m_Buffer, m_Offset + begin + position, buffer, offset, dataLen); } else { // 0 m_End m_Begin m_Capacity // |_______|_______|_______| // | | // (1) m_Position (2) var blockLen = m_Capacity - begin; if (blockLen > position) { //(2) var copyLen = blockLen - position; var remain = dataLen - copyLen; if (remain > 0) { Buffer.BlockCopy(m_Buffer, m_Offset + begin + position, buffer, offset, copyLen); Buffer.BlockCopy(m_Buffer, m_Offset, buffer, offset + copyLen, remain); } else { Buffer.BlockCopy(m_Buffer, m_Offset + begin + position, buffer, offset, dataLen); } } else { //(1) Buffer.BlockCopy(m_Buffer, m_Offset + position - blockLen, buffer, offset, dataLen); } } } catch (Exception e) { UnityEngine.Debug.LogError($"read {m_Position} {m_LimitReadLength} {m_Length} {m_Begin} {m_End} {m_Offset} {m_Capacity}"); throw e; } m_Position += dataLen; return dataLen; } /// <summary> /// 查找字节 /// </summary> /// <param name="offset"></param> /// <param name="origin"></param> /// <returns></returns> /// <exception cref="ArgumentOutOfRangeException"></exception> public override long Seek(long offset, SeekOrigin origin) { Trace($"{offset} {origin}"); var length = m_Length; long position = m_Position; switch (origin) { case SeekOrigin.Begin: position = offset; break; case SeekOrigin.End: position = offset + length; break; case SeekOrigin.Current: position += offset; break; default: throw new ArgumentOutOfRangeException(nameof(origin), origin, null); } m_Position = (int)Math.Max(0, Math.Min(position, length)); return m_Position; } /// <summary> /// 设置长度 /// </summary> /// <param name="value"></param> /// <exception cref="NotImplementedException"></exception> public override void SetLength(long value) { throw new NotImplementedException(); } /// <summary> /// 写入字节 /// </summary> /// <param name="length"></param> /// <returns></returns> public StringBuilder GetHexData(int length = -1) { var sb = new StringBuilder(); var begin = m_Begin; var end = m_End; var count = 0; var maxCount = -1 == length ? m_Length : length; if (end > begin || 0 == m_Length) { for (var i = begin; i < end && count < maxCount; i++, count++) { sb.Append($"{m_Buffer[m_Offset + i]:x2} "); } } else { for (var i = begin; i < m_Capacity && count < maxCount; i++, count++) { sb.Append($"{m_Buffer[m_Offset + i]:x2} "); } for (var i = 0; i < m_End && count < maxCount; i++, count++) { sb.Append($"{m_Buffer[m_Offset + i]:x2} "); } } return sb; } /// <summary> /// 获取字节 /// </summary> /// <param name="buffer"></param> /// <param name="offset"></param> /// <param name="count"></param> /// <returns></returns> private StringBuilder GetHexData(byte[] buffer, int offset, int count) { var sb = new StringBuilder(); for (var i = 0; i < count; i++) { sb.Append($"{buffer[offset + i]:x2} "); } return sb; } /// <summary> /// 写入字节 /// </summary> /// <param name="buffer"></param> /// <param name="offset"></param> /// <param name="count"></param> /// <exception cref="OutOfMemoryException"></exception> /// <exception cref="Exception"></exception> public override void Write(byte[] buffer, int offset, int count) { if (0 == count) return; Trace($"{GetHexData(buffer, offset, count)}"); var position = m_Position; var length = m_Length; if (m_Capacity - position < count) { throw new OutOfMemoryException(); } try { var begin = m_Begin; var end = m_End; var replaceLen = length - position; if (end > begin || 0 == m_Length) { // 0 m_Begin m_End m_Capacity // |_______|_______|_______| // | // m_Position var copyLen = m_Capacity - (begin + position); var remain = count - copyLen; if (remain > 0) { Buffer.BlockCopy(buffer, offset, m_Buffer, m_Offset + begin + position, copyLen); Buffer.BlockCopy(buffer, offset + copyLen, m_Buffer, m_Offset, remain); } else { Buffer.BlockCopy(buffer, offset, m_Buffer, m_Offset + begin + position, count); } } else { // 0 m_End m_Begin m_Capacity // |_______|_______|_______| // | | // (1) m_Position (2) var blockLen = m_Capacity - begin; if (blockLen > position) { //(2) var copyLen = blockLen - position; var remain = count - copyLen; if (remain > 0) { Buffer.BlockCopy(buffer, offset, m_Buffer, m_Offset + begin + position, copyLen); Buffer.BlockCopy(buffer, offset + copyLen, m_Buffer, m_Offset, remain); } else { Buffer.BlockCopy(buffer, offset, m_Buffer, m_Offset + begin + position, count); } } else { //(1) Buffer.BlockCopy(buffer, offset, m_Buffer, m_Offset + position - blockLen, count); } } if (count > replaceLen) { Expand(count - replaceLen); } else { m_Position += count; } } catch (Exception e) { UnityEngine.Debug.LogError($"write {m_Position} {m_LimitReadLength} {m_Length} {m_Begin} {m_End} {m_Offset} {m_Capacity} {count}"); throw e; } Trace($"{GetHexData()}"); } /// <summary> /// 释放 /// </summary> /// <param name="disposing"></param> protected override void Dispose(bool disposing) { base.Dispose(disposing); if (m_Capacity > 0) { m_Buffer = null; m_Capacity = 0; } } #endregion /// <summary> /// 收缩 /// </summary> /// <param name="length"></param> public void Shrink(int length) { Trace($"start {length}"); m_Begin += length; if (m_Begin >= m_Capacity) { m_Begin -= m_Capacity; } if (m_Position <= length) { m_Position = 0; } else { m_Position -= length; } m_Length -= length; Trace($"end {length}"); } /// <summary> /// 扩展 /// </summary> /// <param name="length"></param> public void Expand(int length) { Trace($"start {length}"); m_End += length; if (m_End >= m_Capacity) { m_End -= m_Capacity; } m_Length += length; m_Position = m_Length; Trace($"end {length}"); } /// <summary> /// 开始接收 /// </summary> /// <returns></returns> /// <exception cref="Exception"></exception> public ArraySegment<byte>[] BeginRcv() { Trace(""); try { var length = m_Length; if (m_Capacity == length) { return Array.Empty<ArraySegment<byte>>(); } var begin = m_Begin; var end = m_End; if (end > begin || 0 == m_Length) { // 0 m_Begin m_End m_Capacity // |_______|_______|_______| if (0 == begin) { return new ArraySegment<byte>[] { new ArraySegment<byte>(m_Buffer, m_Offset + end, m_Capacity - end) }; } return new ArraySegment<byte>[] { new ArraySegment<byte>(m_Buffer, m_Offset + end, m_Capacity - end), new ArraySegment<byte>(m_Buffer, m_Offset, begin) }; } else { // 0 m_End m_Begin m_Capacity // |_______|_______|_______| return new ArraySegment<byte>[] { new ArraySegment<byte>(m_Buffer, m_Offset + end, begin - end) }; } } catch (Exception ex) { UnityEngine.Debug.LogError($"{m_Length} {m_Capacity} {m_Begin} {m_End} {m_Offset}"); throw ex; } } /// <summary> /// 结束接收 /// </summary> /// <param name="length"></param> /// <exception cref="OutOfMemoryException"></exception> public void EndRcv(int length) { Trace($"{length}"); if (m_Capacity >= m_Length + length) { Expand(length); } else { throw new OutOfMemoryException(); } } /// <summary> /// 开始发送 /// </summary> /// <returns></returns> public ArraySegment<byte>[] BeginSend() { if (0 == m_Length) return Array.Empty<ArraySegment<byte>>(); var begin = m_Begin; var end = m_End; if (end > begin) { Trace($"offset {m_Offset + begin} len {end - begin}"); // 0 m_Begin m_End m_Capacity // |_______|_______|_______| return new ArraySegment<byte>[] { new ArraySegment<byte>(m_Buffer, m_Offset + begin, end - begin) }; } else { Trace($"offset {m_Offset + begin} len {m_Capacity - begin} offset {m_Offset} len {end}"); // 0 m_End m_Begin m_Capacity // |_______|_______|_______| return new ArraySegment<byte>[] { new ArraySegment<byte>(m_Buffer, m_Offset + begin, m_Capacity - begin), new ArraySegment<byte>(m_Buffer, m_Offset, end) }; } } /// <summary> /// 结束发送 /// </summary> /// <param name="length"></param> /// <exception cref="IndexOutOfRangeException"></exception> public void EndSend(int length) { Trace($"{GetHexData(length)}"); if (m_Length >= length) { Shrink(length); } else { throw new IndexOutOfRangeException(); } } /// <summary> /// 重置 /// </summary> public void Reset() { Trace(""); m_Length = 0; m_Begin = 0; m_End = 0; m_Position = 0; } /// <summary> /// 写入 /// </summary> /// <param name="v"></param> public void Write(int v) { m_Cached[0] = (byte)(v >> 0); m_Cached[1] = (byte)(v >> 8); m_Cached[2] = (byte)(v >> 16); m_Cached[3] = (byte)(v >> 24); Write(m_Cached, 0, 4); } /// <summary> /// 读取 /// </summary> /// <returns></returns> public int ReadInt32() { Read(m_Cached, 0, 4); var result = 0; result |= (int)m_Cached[0]; result |= (int)(m_Cached[1] << 8); result |= (int)(m_Cached[2] << 16); result |= (int)(m_Cached[3] << 24); return result; } /// <summary> /// 写入 /// </summary> /// <param name="v"></param> public void Write(uint v) { m_Cached[0] = (byte)(v >> 0); m_Cached[1] = (byte)(v >> 8); m_Cached[2] = (byte)(v >> 16); m_Cached[3] = (byte)(v >> 24); Write(m_Cached, 0, 4); } /// <summary> /// 读取 /// </summary> /// <returns></returns> public uint ReadUInt32() { Read(m_Cached, 0, 4); uint result = 0; result |= (uint)m_Cached[0]; result |= (uint)(m_Cached[1] << 8); result |= (uint)(m_Cached[2] << 16); result |= (uint)(m_Cached[3] << 24); return result; } /// <summary> /// 写入 /// </summary> /// <param name="v"></param> public void Write(ushort v) { m_Cached[0] = (byte)(v >> 0); m_Cached[1] = (byte)(v >> 8); Write(m_Cached, 0, 2); } /// <summary> /// 读取 /// </summary> /// <returns></returns> public uint ReadUInt16() { Read(m_Cached, 0, 2); ushort result = 0; result |= (ushort)m_Cached[0]; result |= (ushort)(m_Cached[1] << 8); return result; } /// <summary> /// 写入 /// </summary> /// <param name="v"></param> public void Write(short v) { m_Cached[0] = (byte)(v >> 0); m_Cached[1] = (byte)(v >> 8); Write(m_Cached, 0, 2); } /// <summary> /// 读取 /// </summary> /// <returns></returns> public int ReadInt16() { Read(m_Cached, 0, 2); short result = 0; result |= (short)m_Cached[0]; result |= (short)(m_Cached[1] << 8); return result; } /// <summary> /// 写入 /// </summary> /// <param name="v"></param> public void Write(byte v) { m_Cached[0] = v; Write(m_Cached, 0, 1); } /// <summary> /// 读取 /// </summary> /// <returns></returns> public byte ReadUInt8() { Read(m_Cached, 0, 1); return m_Cached[0]; }}py写的游戏开发用的导表工具。目前支持C#脚本。
该工具的原理是将表格数据转换为二进制数据，并生成对应的bytes文件。同时，它还会生成可供访问的C#脚本，使得在游戏中可以通过C#按照二进制字节的方式读取所需的数据。
这个工具的优势在于它可以提高游戏的加载速度和性能。通过将表格数据转换为二进制格式，可以减少文件大小和加载时间。同时，使用C#脚本读取二进制数据可以更高效地访问和处理数据。
该工具目前正在开发中，预计会提供更多功能和优化。敬请期待！
首次运行会在当前目录的Config文件夹下生成一个Config.json配置文件，这个文件里面是导表工具的配置。
这里的配置后续开发将支持QT面板进行修改，不用修改文件。
示例
{ "IsUpdateAllLNG": true, "TablePath": "F:\\MyPrograme\\Excel2Bytes\\Excel2Bytes\\Save\\Table", "BytesPath": "F:\\MyPrograme\\Excel2Bytes\\Excel2Bytes\\Save\\Bytes", "ScriptsPath": "F:\\MyPrograme\\Excel2Bytes\\Excel2Bytes\\Save\\Scripts", "CorePath": "F:\\MyPrograme\\Excel2Bytes\\Excel2Bytes\\Save\\Core", "LNGBytesPath": "F:\\MyPrograme\\Excel2Bytes\\Excel2Bytes\\Save\\Bytes", "ResRefFileListPath": "F:\\MyPrograme\\Excel2Bytes\\Excel2Bytes\\Save\\reslist.json", "LanguageXlsxPath": "F:\\MyPrograme\\Excel2Bytes\\Excel2Bytes\\Save\\Table\\Languages.xlsx", "CNLanguage": "cn", "TableLanguageCSName": "Languages", "BytesExportPath": "", "ScriptsExportPath": "", "CoreExportPath": "", "TableRootNamespace": "LBRuntime", "TableResLoadAssembly": "LBUnity", "ResLoadScripts": "ResManager.OpenFile(\"{0}\")", "LanguageKey": [ "tw", "en" ], "SupportExcelFormats": [ ".xlsx", ".csv" ], "TableSheetInfo": { "ScriptsName": "", "ImportType": "NoneType", "ExtraNamespace": "" }}| 字段 | 描述 |
|---|---|
| IsUpdateAllLNG | 表示是否要更新多语言，如果为False，只有中文语言表会更新，其他的语言不会更新 |
| TablePath | 表格存放的目录 |
| BytesPath | 生成的字节文件存放的目录（非项目内路径，后面有项目内的路径配置，会把这里的文件复制到后面配置的项目路径） |
| ScriptsPath | 生成的脚本文件存放目录（和BytesPath一样是临时存放目录) |
| CorePath | 核心脚本目录，初次导入的时候会生成TableManager等管理脚本存放目录（也是临时存放目录） |
| LNGBytesPath | 多语言的字节生成目录，所有的语言生成的字节文件都是一样的名字，会放在与语言页签同样名字的文件夹下，开发者加载的时候处理不同语言访问的字节文件。 |
| ResRefFileListPath | 收集配置的资源名字的json文件路径（里面存放的都是表里配置的资源的名字） |
| LanguageXlsxPath | 多语言的表格路径，这个是自动生成的。只有处理其他语言显示文字才会修改这个表，这个表的中文页签是会自动更新的 |
| CNLanguage | 多语言表中文页签的页签名 |
| TableLanguageCSName | 读取语言的脚本名字，这里不需要带前缀”Table”（如上图配置，游戏中访问语言就是：TableLanguages.Find(10)） |
| BytesExportPath | 项目里表格字节文件存放的路径，工具会把临时存放的字节文件复制到这个文件里 |
| ScriptsExportPath | 项目里表格脚本文件存放的路径，同上 |
| CoreExportPath | 表格核心脚本存放路径，同上 |
| TableRootNamespace | 表格脚本所在的程序集名字（把导表生成的脚本都放在这个程序集下） |
| TableResLoadAssembly | 脚本加载字节文件的时候需要用到的项目资源加载脚本所在的命名空间 |
| ResLoadScripts | 加载字节文件用到的项目里的方法 |
| LanguageKey | 多语言中其他语言的页签名字 |
| SupportExcelFormats | 表格文件支持的后缀 |
| TableSheetInfo | 页签文件要包含的信息，扩展使用（正常情况下不要修改，增加需要修改代码以作支持） |
首次运行会在当前目录的Config文件夹下生成一个TableConfig.json配置文件，这个文件里面是导表工具的配置。
示例
{ "Global.xlsx": { "Global": { "ScriptsName": "TableGlobal", "ImportType": "CustomTypeField", "ExtraNamespace": "" } }, "Languages.xlsx": { "cn": { "ScriptsName": "TableLanguagescn", "ImportType": "LNGType", "ExtraNamespace": "" }, "tw": { "ScriptsName": "TableLanguagestw", "ImportType": "LNGType", "ExtraNamespace": "" }, "en": { "ScriptsName": "TableLanguagesen", "ImportType": "LNGType", "ExtraNamespace": "" } }, "LanguagesUI.xlsx": { "UI": { "ScriptsName": "TableLanguagesUIUI", "ImportType": "NoExportLNGType", "ExtraNamespace": "" } }, "Level.xlsx": { "Level": { "ScriptsName": "TableLevel", "ImportType": "FindType", "ExtraNamespace": "" }, "Chase": { "ScriptsName": "TableLevelChase", "ImportType": "FindType", "ExtraNamespace": "" } }, "ResName.xlsx": { "ResName": { "ScriptsName": "TableResName", "ImportType": "FieldType", "ExtraNamespace": "" }, "ArrayResName": { "ScriptsName": "TableResNameArrayResName", "ImportType": "FieldType", "ExtraNamespace": "" } }, "Text.xlsx": { "System": { "ScriptsName": "TableTextSystem", "ImportType": "FieldType", "ExtraNamespace": "" }, "Network": { "ScriptsName": "TableTextNetwork", "ImportType": "NoneType", "ExtraNamespace": "" }, "SystemFind": { "ScriptsName": "TableTextSystemFind", "ImportType": "NoneType", "ExtraNamespace": "" }, "SystemArray": { "ScriptsName": "TableTextSystemArray", "ImportType": "FieldType", "ExtraNamespace": "" }, "Rich": { "ScriptsName": "TableTextRich", "ImportType": "NoneType", "ExtraNamespace": "" } }}| key | 描述 |
|---|---|
| ScriptsName | 表示生成的脚本的名字，也是字节文件的名字 |
| ImportType | 表示导入类型，NoneType代表不导入，其他类型下文会介绍 |
| ExtraNamespace | 表示生成脚本文件需要额外引用的命名空间 |
每个表格得每个页签都需要选择一个导入类型，没选择导入类型得页签代表不进行导入。导入类型决定了生成得表格数据得bytes文件和对应得脚本文件。
类型总览：
| 导入类型 | 描述 |
|---|---|
| FieldType | 字段类型，用于配置游戏中动态替换的数据（注：只允许含有c的字段两列，一列是代码访问关键字，一列是值） |
| FindType | 查找类型，用于配置游戏中的数据，根据关键字进行查找对应数据。 |
| LNGType | 语言类型，用于存放所有语言的表，这个表工具会自动生成，不需要手动创建 |
| NoExportLNGType | 无导入语言类型，用于游戏中固定的文字，非代码访问的，需要玩家自动创建并收集游戏中的文字（注：导表是不会生成脚本和bytes文件，只是为了收集游戏中语言到语言表里） |
| CustomTypeField | 针对此类型表专门做的类型。(注：只允许含有c的字段三列，一列是代码访问关键字，一列是值得类型，一列是值) |
字段的导入类型，用于根据字段的关键字来访问对应的值。此类型只允许有两列第一行包含’c’的列（第一行包含’c’代表要导入的数据），一列是代码访问关键字，一列是值。
示例
| c | c |
|---|---|
| ID | text |
| int | LNGRef |
| 名称 | 内容 |
| NetworkUnreachable | 连接出错，请检查您的网络！ |
| GetServerListFailed | 拉取服务器列表失败，请稍后再试！ |
| TipsFormatInitParamFailed | 初始化参数请求失败，请检查您的网络！{0} |
在这个示例中，我们展示了一个普通表格的结构。每一列都有一个对应的数据类型和字段描述。
在第一行中，我们使用了字符c来表示是否要导入该列的数据。只有含有c的列才会被导入到数据文件中。
在第二行中，我们列出了每一列的字段名字。这些字段名字用于标识每一列所代表的数据。
在第三行中，我们指定了每一列数据的类型。这些类型可以是整数(int)、字符串(string)、长整型(long)等。
在第四行中，我们提供了对每一列所代表的字段的描述。这些描述可以帮助读者更好地理解每一列数据的含义。
接下来的行中，第一列表示的是我们要搜索的关键字，第二列就是关键字对应的数值
查找的导入类型，用于根据数据的key查找对应的数据，此类型包含’c’的列至少是两列，一列是查找的时候的关键字，后面就是一系列的配置数据了。
示例
| c | c | c | |
|---|---|---|---|
| ID | Level | des | Exp |
| int | int | string | long |
| 关键key | 等级 | 描述 | 经验 |
| 1 | 1 | 练气 | 100 |
在这个示例中，我们展示了一个普通表格的结构。每一列都有一个对应的数据类型和字段描述。
在第一行中，我们使用了字符c来表示是否要导入该列的数据。只有含有c的列才会被导入到数据文件中。
在第二行中，我们列出了每一列的字段名字。这些字段名字用于标识每一列所代表的数据。
在第三行中，我们指定了每一列数据的类型。这些类型可以是整数(int)、字符串(string)、长整型(long)等。
在第四行中，我们提供了对每一列所代表的字段的描述。这些描述可以帮助读者更好地理解每一列数据的含义。
接下来的行中，我们可以输入对应的数据。在这个示例中，我们输入了一条数据，其中ID为1，等级为1，描述为”练气”，经验为100。
以上是对普通表格的描述和示例。你可以根据需要调整表格的结构和内容。
这个是语言表类型，是导表工具自动生成的多语言表内的页签用的类型，这个类型的表在生成多语言的时候每页都会生成一个语言的字节文件，游戏可以在加载字节文件里做处理，只需要加载对应语言即可。
示例
| c | c |
|---|---|
| ID | text |
| uint | string |
| 编号 | 文本 |
| 1 | 多语言1 |
| 2 | 多语言2 |
这个语言表会自动生成，不需要创建，只需要添加要生成语言的配置即可
这个类型的表也是语言类型表，这个表需要玩家自己收集游戏中不是动态变化的语言，类似Unity的prefab上的语言，导表的时候会把这些语言收集到多语言表中，并且不会生成脚本和字节文件，游戏中开发者只需要通过id访问语言表的字节文件即可。
示例
| c | c |
|---|---|
| ID | text |
| uint | LNGRef |
| 编号 | 文本 |
| 1 | 多语言1 |
| 2 | 多语言2 |
自定义类型的字段导入类型，这个和字段导入类型差不多，但是要求有效列(第一行含’c’)的列必须是三列。
示例
| c | c | c |
|---|---|---|
| 关键字 | 类型 | 值 |
| currencyFormatSplit | nt[] | 5|7 |
| currencyNumSplit | slc|int | 4|7 |
| currencyFormatSplitMap | map|int | string |
| currencyFormatSplitDic | Dictionary<int,LNGRef> | 1:你好|2:我不好 |
在这个示例中，我们展示了一个多类型表格的结构。每一行都有一个对应的数据类型和字段描述。
在第一行中，我们使用了字符c来表示是否要导入该列的数据。只有含有c的列才会被导入到数据文件中。
在第二行中，我们提供了对每一列所代表的字段的描述。这些描述可以帮助读者更好地理解每一列数据的含义。
以上是对多类型表格的描述和示例。你可以根据需要调整表格的结构和内容。
后续版本会支持界面按钮调用，目前仅支持命令。(注：需要配置python环境)
| 命令 | 解释 |
|---|---|
| python Excel2Bytes.py -a | 表示要导入表格配置里的所有表格数据，并且会生成多语言 |
| python Excel2Bytes.py -e | 表示只导入NoExportLNGType类型的表，用于游戏中固定文本的多语言生成 |
| python Excel2Bytes.py -c [“Global.xlsx”,”Level.xlsx”] | 表示只导入我传入的第二个参数里面包含的表，只会生成中文的语言，其他多语言不会生成 |
| 类型 | 写法 | 描述 |
|---|---|---|
| uint8 | 1 | 基础类型 |
| byte | 1 | 基础类型 |
| int | 1 | 基础类型 |
| uint | 1 | 基础类型 |
| float | 1 | 基础类型 |
| double | 1 | 基础类型 |
| bool | false、true或者空 | 基础类型 |
| long | 1 | 基础类型 |
| ulong | 1 | 基础类型 |
| int64 | 1 | 基础类型 |
| uint | 64 | 基础类型 |
| short | 1 | 基础类型 |
| ushort | 1 | 基础类型 |
| string | 文本描述 | 基础类型 |
| 基础类型[] | 1|1 | 3 |
| slc|基础类型 | 1|1 | 3 |
| 基础类型[][] | 1:2:3|1:2 | 1:2:3:4 |
| double_slc|基础类型 | 1:2:3|1:2 | 1:2:3:4 |
| map|基础类型 | 基础类型 | 1:2|3:4 |
| Dictionary<基础类型，基础类型> | 1:2|3:4 | 5:6 |
| LNGRef | 这段话多语言 | 字符串类型，会在多语言表生成，用于游戏语言切换功能 |
| ResName | Icon.png | 资源类型，这里会收集表里配置的所有资源，可根据自身需求来获取，Save目录会生成reslist.json，记录了所有的资源 |
本文介绍了一个用于辅助生成C#脚本的Python工具。该工具可以帮助用户快速生成C#脚本，并提供了一些常用的代码生成方法。
import osfrom PathUtil import ScriptsPathclass CSScriptBuilder(list): BlackNum = 0 def Append(self, message): if self.BlackNum > 0: self.append('\t' * self.BlackNum + message) else: self.append(message) def AppendEnter(self): self.Append('\n') def AppendLine(self, message): if len(self) > 0: self.append('\n') if self.BlackNum > 0: self.append('\t' * self.BlackNum + message) else: self.append(message) def AppendEmptyLine(self): self.AppendLine('') def AppendUsing(self, namespace): self.AppendLine(f'using {namespace};') def BeginNamespace(self, namespace): self.AppendLine(f'namespace {namespace}') self.BeginBrace() def EndNamespace(self): self.EndBrace() def BeginClass(self, className, modifier="public", superclass=None): if superclass is not None: self.AppendLine(f'{modifier} class {className} : {superclass}') else: self.AppendLine(f'{modifier} class {className}') self.BeginBrace() def EndClass(self): self.EndBrace() def BeginStruct(self, structName, modifier="public"): self.AppendLine(f'{modifier} struct {structName}') self.BeginBrace() def EndStruct(self): self.EndBrace() def BeginEnum(self, enumName, modifier="public"): self.AppendLine(f'{modifier} enum {enumName}') self.BeginBrace() def EndEnum(self): self.EndBrace() def AppendEnumField(self, fieldName, fieldValue): self.AppendLine(f'{fieldName} = {fieldValue},') def BeginInterface(self, interfaceName, modifier="public"): self.AppendLine(f'{modifier} interface {interfaceName}') self.BeginBrace() def EndInterface(self): self.EndBrace() def AppendInterfaceMethod(self, methodName, returnType='void', parameters=''): self.AppendLine(f'{returnType} {methodName}({parameters});') def AppendField(self, propertyName, propertyType, modifier="public", init=''): if len(init) > 0: self.AppendLine(f'{modifier} {propertyType} {propertyName} = {init};') else: self.AppendLine(f'{modifier} {propertyType} {propertyName};') def AppendProperty(self, propertyName, propertyType, field=None, modifier="public"): if field is not None: self.AppendLine(f'{modifier} {propertyType} {propertyName} => {field};') else: self.AppendLine(f'{modifier} {propertyType} {propertyName} {{ get; set; }}') def BeginProperty(self, propertyName, propertyType, modifier="public"): self.AppendLine(f'{modifier} {propertyType} {propertyName}') self.BeginBrace() def EndProperty(self): self.EndBrace() def BeginMethod(self, methodName, modifier="public", returnType='void', parameters=''): self.AppendLine(f'{modifier} {returnType} {methodName}({parameters})') self.BeginBrace() def BeginConstructionMethod(self, methodName, modifier="public", parameters=''): self.AppendLine(f'{modifier} {methodName}({parameters})') self.BeginBrace() def EndMethod(self): self.EndBrace() def BeginIf(self, condition): self.AppendLine(f'if ({condition})') self.BeginBrace() def BeginElif(self, condition): self.AppendLine(f'else if ({condition})') self.BeginBrace() def EndIf(self): self.EndBrace() def BeginWhile(self, condition): self.AppendLine(f'while ({condition})') self.BeginBrace() def EndWhile(self): self.EndBrace() def BeginTry(self): self.AppendLine('try') self.BeginBrace() def EndTry(self): self.EndBrace() def BeginCatch(self, exceptionType): self.AppendLine(f'catch ({exceptionType})') self.BeginBrace() def BeginForEach(self, name, collection, singleType='var'): self.AppendLine(f'foreach ({singleType} {name} in {collection})') self.BeginBrace() def EndForEach(self): self.EndBrace() def BeginFor(self, condition): self.AppendLine(f'for ({condition})') self.BeginBrace() def EndFor(self): self.EndBrace() def BeginForRange(self, name, start, end): self.AppendLine(f'for (int {name} = {start}; {name} < {end}; {name}++)') self.BeginBrace() def EndForRange(self): self.EndBrace() def EndCatch(self): self.EndBrace() def BeginBlank(self): self.BlackNum += 1 def EndBlank(self): self.BlackNum -= 1 def BeginBrace(self): self.AppendLine('{') self.BeginBlank() def EndBrace(self): self.EndBlank() self.AppendLine('}') def BeginRegion(self, regionName): self.AppendLine(f'#region {regionName}') self.AppendEmptyLine() def EndRegion(self): self.AppendEmptyLine() self.AppendLine('#endregion') self.AppendEmptyLine() def ToString(self): return ''.join(self) def GenerateScript(self, fileName, isDefPath=True): fileName = fileName.replace('.cs', '') if isDefPath: fileName = os.path.join(ScriptsPath, fileName) with open(f'{fileName}.cs', 'w', encoding='utf-8') as f: f.write(self.ToString())def CreateTableManagerCs(): script = CSScriptBuilder() script.AppendUsing('System.Collections.Generic') script.AppendUsing('UnityEngine') script.BeginNamespace(TableLoadAssembly) script.BeginInterface('ITable', 'public') script.AppendInterfaceMethod('Dispose') script.EndInterface() script.AppendEmptyLine() script.BeginClass('TableManager', 'public static') script.AppendField('s_Inited', 'bool', 'private static') script.AppendField('s_Cached', 'List<ITable>', 'private static', 'new List<ITable>()') # 添加方法 script.AppendEmptyLine() script.BeginMethod("Add", parameters="ITable table") script.AppendLine("Debug.Assert(s_Inited, \"add but TableManager not init \");") script.AppendLine("s_Cached.Add(table);") script.EndMethod() script.AppendEmptyLine() script.BeginMethod("Remove", parameters="ITable table") script.AppendLine("Debug.Assert(s_Inited, \"remove but TableManager not init\");") script.AppendLine("if (s_Cached.Remove(table))") script.BeginBrace() script.AppendLine("table.Dispose();") script.EndBrace() script.EndMethod() script.AppendEmptyLine() script.BeginMethod("Init") script.AppendLine("Debug.Assert(!s_Inited, \"TableManager already init\");") script.AppendLine("s_Inited = true;") script.EndMethod() script.AppendEmptyLine() script.BeginMethod("UnInit") script.AppendLine("Debug.Assert(s_Inited, \"TableManager not init\");") script.AppendLine("s_Inited = false;") script.AppendLine("foreach (var table in s_Cached)") script.BeginBrace() script.AppendLine("table.Dispose();") script.EndBrace() script.AppendLine("s_Cached.Clear();") script.EndMethod() script.EndClass() script.EndNamespace() script.GenerateScript(os.path.join(ScriptsPath, 'TableManager'))以上是本文介绍的C#脚本生成辅助工具的代码示例。工具的核心是一个名为CSScriptBuilder的类，它继承自list，并提供了一系列用于生成C#脚本的方法。
通过使用这个工具，用户可以更加方便地生成C#脚本，提高开发效率。
希望本文对您理解这个工具的用途和使用方法有所帮助。如果您有任何问题或建议，欢迎留言讨论。
]]>
本文介绍了一种用于编辑器开发过程中树形结构数据进行渲染的辅助脚本。
TreeElementGUI是树形结构元素渲染的基类，包含了节点深度、父节点、子节点、节点名字、节点ID等属性，并且提供了无参构造函数和有参构造函数。
/// <summary>/// 树结构的元素/// </summary>public abstract class TreeElementGUI{ private int m_ID; private string m_Name; private int m_Depth; [NonSerialized] private TreeElementGUI m_Parent; [NonSerialized] private List<TreeElementGUI> m_Children; /// <summary> /// 深度 /// </summary> public int Depth { get => m_Depth; set => m_Depth = value; } /// <summary> /// 父节点 /// </summary> public TreeElementGUI Parent { get => m_Parent; set => m_Parent = value; } /// <summary> /// 子节点 /// </summary> public List<TreeElementGUI> Children { get => m_Children; set => m_Children = value; } /// <summary> /// 是否有子节点 /// </summary> public bool HasChildren => m_Children != null && m_Children.Count > 0; /// <summary> /// 节点名字 /// </summary> public string Name { get => m_Name; set => m_Name = value; } /// <summary> /// 节点ID /// </summary> public int Id { get => m_ID; set => m_ID = value; } /// <summary> /// 无参构造函数 /// </summary> protected TreeElementGUI() :this(-1, -1, "") { } /// <summary> /// 有参构造函数 /// </summary> /// <param name="id"></param> /// <param name="depth"></param> /// <param name="name"></param> protected TreeElementGUI(int id, int depth, string name) { m_Name = name; m_ID = id; m_Depth = depth; } public abstract void OnGUI(Rect rect, int columnIndex); public abstract bool IsMatchSearch(string search);}TreeViewItemGUI
/// <summary>/// 树结构编辑器显示/// </summary>/// <typeparam name="T"></typeparam>public class TreeViewItemGUI<T> : TreeViewItem where T : TreeElementGUI{ private readonly T m_Data; public T Data => m_Data; public TreeViewItemGUI(int id, int depth, string displayName, T data) : base(id, depth, displayName) { m_Data = data; } public void OnGUI(Rect rect, int columnIndex) { m_Data.OnGUI(rect, columnIndex); } public bool IsMatchSearch(string search) { return m_Data.IsMatchSearch(search); }}TreeGUIUtility是一个用于编辑器开发过程中树形结构数据进行渲染的辅助脚本。该脚本包含了一些常用的方法，可以帮助开发者处理树形结构数据。
其中，TreeToList
public static class TreeGUIUtility{ public static void TreeToList<T>(T root, IList<T> result) where T : TreeElementGUI { if (result == null) throw new NullReferenceException("The input 'IList<T> result' list is null"); result.Clear(); var stack = new Stack<T>(); stack.Push(root); while (stack.Count > 0) { var current = stack.Pop(); result.Add(current); if (current.Children != null && current.Children.Count > 0) { for (var i = current.Children.Count - 1; i >= 0; i--) { stack.Push((T)current.Children[i]); } } } } public static T Find<T>(T root, Func<T, bool> comparer) where T : TreeElementGUI { var stack = new Stack<T>(); stack.Push(root); while (stack.Count > 0) { var current = stack.Pop(); if(root != current && comparer(current)) { return current; } if (current.Children != null && current.Children.Count > 0) { for (var i = current.Children.Count - 1; i >= 0; i--) { stack.Push((T)current.Children[i]); } } } return null; } /// <summary> /// List转成树结构 /// </summary> /// <param name="list"></param> /// <typeparam name="T"></typeparam> /// <returns></returns> public static T ListToTree<T>(IList<T> list) where T : TreeElementGUI { // 验证深度的值 ValidateDepthValues(list); // 清理状态 foreach (var element in list) { element.Parent = null; element.Children = null; } // 设置子节点和父节点 for (var parentIndex = 0; parentIndex < list.Count; parentIndex++) { var parent = list[parentIndex]; var alreadyHasValidChildren = parent.Children != null; if (alreadyHasValidChildren) continue; var parentDepth = parent.Depth; var childCount = 0; // Count children based depth value, we are looking at children until it's the same depth as this object for (var i = parentIndex + 1; i < list.Count; i++) { if (list[i].Depth == parentDepth + 1) childCount++; if (list[i].Depth <= parentDepth) break; } // Fill child array List<TreeElementGUI> childList = null; if (childCount != 0) { childList = new List<TreeElementGUI>(childCount); // Allocate once childCount = 0; for (var i = parentIndex + 1; i < list.Count; i++) { if (list[i].Depth == parentDepth + 1) { list[i].Parent = parent; childList.Add(list[i]); childCount++; } if (list[i].Depth <= parentDepth) break; } } parent.Children = childList; } return list[0]; } /// <summary> /// 检查List的深度值 /// </summary> /// <param name="list"></param> /// <typeparam name="T"></typeparam> /// <exception cref="ArgumentException"></exception> public static void ValidateDepthValues<T>(IList<T> list) where T : TreeElementGUI { if (list.Count == 0) throw new ArgumentException("list should have items, count is 0, check before calling ValidateDepthValues", nameof(list)); if (list[0].Depth != -1) throw new ArgumentException("list item at index 0 should have a depth of -1 (since this should be the hidden root of the tree). Depth is: " + list[0].Depth, nameof(list)); for (var i = 0; i < list.Count - 1; i++) { var depth = list[i].Depth; var nextDepth = list[i + 1].Depth; if (nextDepth > depth && nextDepth - depth > 1) throw new ArgumentException(string.Format("Invalid depth info in input list. Depth cannot increase more than 1 per row. Index {0} has depth {1} while index {2} has depth {3}", i, depth, i + 1, nextDepth)); } for (var i = 1; i < list.Count; ++i) if (list[i].Depth < 0) throw new ArgumentException("Invalid depth value for item at index " + i + ". Only the first item (the root) should have depth below 0."); if (list.Count > 1 && list[1].Depth != 0) throw new ArgumentException("Input list item at index 1 is assumed to have a depth of 0", nameof(list)); } /// <summary> /// 更新深度值 /// </summary> /// <param name="root"></param> /// <typeparam name="T"></typeparam> /// <exception cref="ArgumentNullException"></exception> public static void UpdateDepthValues<T>(T root) where T : TreeElementGUI { if (root == null) throw new ArgumentNullException(nameof(root), "The root is null"); if (!root.HasChildren) return; var stack = new Stack<TreeElementGUI>(); stack.Push(root); while (stack.Count > 0) { var current = stack.Pop(); if (current.Children != null) { foreach (var child in current.Children) { child.Depth = current.Depth + 1; stack.Push(child); } } } } /// <summary> /// 判断是否是子节点 /// </summary> /// <param name="child"></param> /// <param name="elements"></param> /// <typeparam name="T"></typeparam> /// <returns></returns> static bool IsChildOf<T>(T child, IList<T> elements) where T : TreeElementGUI { while (child != null) { child = (T)child.Parent; if (elements.Contains(child)) return true; } return false; } /// <summary> /// 查找共同的祖先节点 /// </summary> /// <param name="elements"></param> /// <typeparam name="T"></typeparam> /// <returns></returns> public static IList<T> FindCommonAncestorsWithinList<T>(IList<T> elements) where T : TreeElementGUI { if (elements.Count == 1) return new List<T>(elements); var result = new List<T>(elements); result.RemoveAll(g => IsChildOf(g, elements)); return result; }}TreeGUIModel
public class TreeGUIModel<T> where T : TreeElementGUI, new(){ private T m_Root; private int m_MaxID; private bool m_IsDirty; public T Root => m_Root; public event Action<T> added; public event Action<T> removed; public int Count => m_Root.Children.Count; public bool IsDirty => m_IsDirty; public TreeGUIModel() { m_Root = new T { Id = GenerateUniqueID(), Depth = -1, Name = $"{typeof(T).Name} - Root", Children = new List<TreeElementGUI>() }; m_IsDirty = true; } /// <summary> /// 根据id查找元素 /// </summary> /// <param name="id"></param> /// <returns></returns> public T Find(int id) { return (T)m_Root.Children.FirstOrDefault(element => element.Id == id); } /// <summary> /// 自动生成唯一ID /// </summary> /// <returns></returns> public int GenerateUniqueID() { return ++m_MaxID; } /// <summary> /// 获得所有的子节点 /// </summary> /// <param name="id"></param> /// <returns></returns> public IList<int> GetAncestors(int id) { var parents = new List<int>(); var item = Find(id); if (item != null) { while (item.Parent != null) { parents.Add(item.Parent.Id); item = (T)item.Parent; } } return parents; } /// <summary> /// 获得有子节点的所有子节点 /// </summary> /// <param name="id"></param> /// <returns></returns> public IList<int> GetDescendantsThatHaveChildren(int id) { var searchFromThis = Find(id); return searchFromThis != null ? GetParentsBelowStackBased(searchFromThis) : new List<int>(); } /// <summary> /// 获得基于栈的所有子节点 /// </summary> /// <param name="searchFromThis"></param> /// <returns></returns> private IList<int> GetParentsBelowStackBased(TreeElementGUI searchFromThis) { var stack = new Stack<TreeElementGUI>(); stack.Push(searchFromThis); var parentsBelow = new List<int>(); while (stack.Count > 0) { var current = stack.Pop(); if (current.HasChildren) { parentsBelow.Add(current.Id); foreach (var T in current.Children) { stack.Push(T); } } } return parentsBelow; } /// <summary> /// 移除元素 /// </summary> /// <param name="elementID"></param> public void RemoveElements(int elementID) { var elements = m_Root.Children.Where(element => element.Id == elementID).Cast<T>().ToArray(); RemoveElements(elements); } /// <summary> /// 移除元素 /// </summary> /// <param name="elementIDs"></param> public void RemoveElements(IList<int> elementIDs) { var elements = m_Root.Children.Where(element => elementIDs.Contains(element.Id)).Cast<T>().ToArray(); RemoveElements(elements); } /// <summary> /// 移除元素 /// </summary> /// <param name="elements"></param> public void RemoveElements(IList<T> elements) { var commonAncestors = TreeGUIUtility.FindCommonAncestorsWithinList(elements); foreach (var element in commonAncestors) { element.Parent.Children.Remove(element); element.Parent = null; removed?.Invoke(element); } SetDirty(); } /// <summary> /// 增加元素 /// </summary> /// <param name="elements"></param> /// <param name="parent"></param> /// <param name="insertPosition"></param> /// <param name="isNew"></param> /// <exception cref="ArgumentNullException"></exception> public void AddElements(IList<T> elements, TreeElementGUI parent, int insertPosition, bool isNew = false) { if (elements == null) throw new ArgumentNullException(nameof(elements), "elements is null"); if (elements.Count == 0) throw new ArgumentNullException(nameof(elements), "elements Count is 0: nothing to add"); if (parent == null) throw new ArgumentNullException(nameof(parent), "parent is null"); parent.Children ??= new List<TreeElementGUI>(); parent.Children.InsertRange(insertPosition, elements); foreach (var element in elements) { element.Parent = parent; element.Depth = parent.Depth + 1; TreeGUIUtility.UpdateDepthValues(element); if(isNew) { added?.Invoke(element); } } SetDirty(); } /// <summary> /// 增加元素 /// </summary> /// <param name="root"></param> /// <param name="isNew"></param> public void AddElement(T root, bool isNew = false) { root.Id = GenerateUniqueID(); root.Depth = -1; root.Parent = m_Root; m_Root.Children.Add(root); if(isNew) { added?.Invoke(root); } SetDirty(); } /// <summary> /// 增加元素 /// </summary> /// <param name="element"></param> /// <param name="parent"></param> /// <param name="insertPosition"></param> /// <param name="isNew"></param> public void AddElement(T element, T parent, int insertPosition, bool isNew = false) { parent.Children ??= new List<TreeElementGUI>(); parent.Children.Insert(insertPosition, element); element.Parent = parent; TreeGUIUtility.UpdateDepthValues(parent); if (isNew) { added?.Invoke(element); } SetDirty(); } /// <summary> /// 移动元素 /// </summary> /// <param name="parentElement"></param> /// <param name="insertionIndex"></param> /// <param name="elements"></param> /// <exception cref="ArgumentException"></exception> public void MoveElements(TreeElementGUI parentElement, int insertionIndex, List<TreeElementGUI> elements) { if (insertionIndex < 0) throw new ArgumentException("Invalid input: insertionIndex is -1, client needs to decide what index elements should be reparented at"); // Invalid reparenting input if (parentElement == null) return; // We are moving items so we adjust the insertion index to accomodate that any items above the insertion index is removed before inserting if (insertionIndex > 0) insertionIndex -= parentElement.Children.GetRange(0, insertionIndex).Count(elements.Contains); // Remove draggedItems from their parents foreach (var draggedItem in elements) { draggedItem.Parent.Children.Remove(draggedItem); // remove from old parent draggedItem.Parent = parentElement; // set new parent } parentElement.Children ??= new List<TreeElementGUI>(); // Insert dragged items under new parent parentElement.Children.InsertRange(insertionIndex, elements); TreeGUIUtility.UpdateDepthValues(Root); SetDirty(); } /// <summary> /// 标记为脏 /// </summary> private void SetDirty() { m_IsDirty = true; } /// <summary> /// 清理 /// </summary> public void Clear() { m_Root.Children.Clear(); SetDirty(); } /// <summary> /// 更新 /// </summary> internal void Update() { m_IsDirty = true; }}TreeViewWithGUIModel
该类还包含了一些属性，用于控制树形结构数据的外观和行高等。
TreeViewWithGUIModel
public abstract class TreeViewWithGUIModel<T> : TreeView where T : TreeElementGUI, new(){ protected TreeGUIModel<T> m_TreeModel; private readonly List<TreeViewItem> m_Rows = new List<TreeViewItem>(100); public bool ShowAlternatingRowBackgrounds { get => showAlternatingRowBackgrounds; set => showAlternatingRowBackgrounds = value; } public bool ShowBorder { get => showBorder; set => showBorder = value; } public float RowHeight { get => rowHeight; set => rowHeight = value; } protected TreeViewWithGUIModel(TreeViewState state, TreeGUIModel<T> model) : base(state) { Init(model); } protected TreeViewWithGUIModel(TreeViewState state, MultiColumnHeader multiColumnHeader, TreeGUIModel<T> model) : base(state, multiColumnHeader) { Init(model); multiColumnHeader.sortingChanged += OnSortingChanged; } private void Init(TreeGUIModel<T> model) { m_TreeModel = model; } private void OnSortingChanged(MultiColumnHeader _multiColumnHeader) { SortIfNeeded(rootItem, m_Rows); } private void SortIfNeeded(TreeViewItem root, List<TreeViewItem> rows) { if( null == multiColumnHeader) return; if ( rows.Count <= 1) return; if (multiColumnHeader.sortedColumnIndex == -1) { return; // No column to sort for (just use the order the data are in) } // Sort the roots of the existing tree items rootItem.children = SortByMultipleColumns(rows); TreeToList(root, rows); Repaint(); } public static void TreeToList(TreeViewItem root, IList<TreeViewItem> result) { if (root == null) throw new NullReferenceException("root"); if (result == null) throw new NullReferenceException("result"); result.Clear(); if (root.children == null) return; var stack = new Stack<TreeViewItem>(); for (var i = root.children.Count - 1; i >= 0; i--) stack.Push(root.children[i]); while (stack.Count > 0) { var current = stack.Pop(); result.Add(current); if (current.hasChildren && current.children[0] != null) { for (var i = current.children.Count - 1; i >= 0; i--) { stack.Push(current.children[i]); } } } } protected override TreeViewItem BuildRoot() { return null == m_TreeModel.Root ? new TreeViewItemGUI<T>(0, -1, "Root", null) : new TreeViewItemGUI<T>(m_TreeModel.Root.Id, -1, m_TreeModel.Root.Name, m_TreeModel.Root); } protected override bool DoesItemMatchSearch(TreeViewItem item, string search) { var target = (TreeViewItemGUI<T>)item; return target.IsMatchSearch(search); } protected override void RowGUI(RowGUIArgs args) { var item = (TreeViewItemGUI<T>) args.item; if (null == multiColumnHeader) { item.OnGUI(args.rowRect, 0); } else { var columns = args.GetNumVisibleColumns(); for (var i = 0; i < columns; i++) { var rt = args.GetCellRect(i); CenterRectUsingSingleLineHeight(ref rt); item.OnGUI(rt, args.GetColumn(i)); } } } protected override IList<TreeViewItem> BuildRows(TreeViewItem root) { m_Rows.Clear(); if (m_TreeModel.Root == null) { return m_Rows; } if (hasSearch) { Search(m_TreeModel.Root, searchString, m_Rows); } else if (m_TreeModel.Root.HasChildren) { AddChildrenRecursive(root, m_TreeModel.Root, 0, m_Rows); } SortIfNeeded(root, m_Rows); return m_Rows; } private void AddChildrenRecursive(TreeViewItem root, T parent, int depth, IList<TreeViewItem> newRows) { foreach (var treeElement in parent.Children) { var child = (T) treeElement; var item = new TreeViewItemGUI<T>(child.Id, depth, child.Name, child); newRows.Add(item); root.AddChild(item); if (child.HasChildren) { if (IsExpanded(child.Id)) { AddChildrenRecursive(item, child, depth + 1, newRows); } else { item.children = CreateChildListForCollapsedParent(); } } } } private void Search(T searchFromThis, string search, List<TreeViewItem> result) { if (string.IsNullOrEmpty(search)) throw new ArgumentException("Invalid search: cannot be null or empty", nameof(search)); var stack = new Stack<T>(); foreach (var element in searchFromThis.Children) stack.Push((T)element); while (stack.Count > 0) { var current = stack.Pop(); // Matches search? if (current.IsMatchSearch(search)) { result.Add(new TreeViewItemGUI<T>(current.Id, 0, current.Name, current)); } if (current.Children != null && current.Children.Count > 0) { foreach (var element in current.Children) { stack.Push((T)element); } } } SortSearchResult(result); } public override IList<TreeViewItem> GetRows() { return m_Rows; } protected virtual void SortSearchResult(List<TreeViewItem> rows) { // sort by displayName by default, can be overriden for multColumn solutions rows.Sort((x, y) => EditorUtility.NaturalCompare(x.displayName, y.displayName)); } protected virtual List<TreeViewItem> SortByMultipleColumns(List<TreeViewItem> children) { return children; } public Rect DoLayout(params GUILayoutOption[] options) { if(m_TreeModel.IsDirty) { m_TreeModel.Update(); Reload(); } GUILayout.BeginVertical(); var rect = GUILayoutUtility.GetRect(GUIContent.none, GUIStyle.none, options); OnGUI(rect); GUILayout.EndVertical(); return rect; }}在游戏开发中，FPS（Frames Per Second）是一个非常重要的指标，它可以反映出游戏的流畅度和性能。为了帮助开发者更好地优化游戏性能，我们可以使用一个自制的游戏FPS显示工具，实时显示当前的帧率。
以下是自制的游戏FPS显示工具的代码实现：
public class FPSUtils : MonoBehaviour{ #region 实例化 private static FPSUtils s_FPS = null; /// <summary> /// 实例化一个FPS单位 /// </summary> /// <param name="parent"></param> public static void CreateInstance(GameObject parent = null) { if (s_FPS != null) return; var go = new GameObject("FPS"); s_FPS = go.AddComponent<FPSUtils>(); if (null == parent) { DontDestroyOnLoad(go); } else { go.SetParent(parent); go.SetAsFirstSibling(); } } /// <summary> /// 销毁一个FPS单位 /// </summary> public static void DestroyInstance() { if (null != s_FPS) { Destroy(s_FPS.gameObject); s_FPS = null; } } #endregion #region FPS统计 /// <summary> /// 是否显示FPS /// </summary> private bool m_IsShowFPS = true; /// <summary> /// 帧数计算刷新时间（s） /// </summary> private const float m_ShowTime = 1f; /// <summary> /// 当前时间 /// </summary> private float m_CurTime = 0f; /// <summary> /// 当前帧数 /// </summary> private static int m_Frames = 0; /// <summary> /// 临时FPS /// </summary> private int m_TempFPS = 0; /// <summary> /// 帧数变化比较容忍度 /// </summary> private const int TOLERANCE = 5; /// <summary> /// 当前FPS /// </summary> private int m_CurFPS; /// <summary> /// 当前显示的帧数 /// </summary> private int m_CurShowFPS; /// <summary> /// 品质当前时间 /// </summary> private float m_QualityCurTime = 0f; /// <summary> /// 品质的容忍度 /// </summary> private const int m_TotalTime = 10; /// <summary> /// 帧数容忍度 /// </summary> private const int m_MaxFrameCount = 200; /// <summary> /// 最小FPS容忍度 /// </summary> private const int m_MinFPS = 10; /// <summary> /// 当前最小帧数 /// </summary> private int m_CurMinFrmCount = 0; private void Update() { m_CurTime += Time.unscaledDeltaTime; m_Frames++; m_CurFPS = (int)(1.0f / Time.unscaledDeltaTime); if (m_CurTime >= m_ShowTime) { m_CurShowFPS = (int)(m_Frames / m_CurTime); if (Math.Abs(m_CurShowFPS - m_TempFPS) > TOLERANCE) { m_TempFPS = m_CurShowFPS; } m_CurTime = 0; m_Frames = 0; } } private void FixedUpdate() { m_QualityCurTime += Time.unscaledDeltaTime; if (m_QualityCurTime >= m_TotalTime) { m_CurMinFrmCount = 0; m_QualityCurTime = 0; } if (m_CurFPS >= m_MinFPS) return; m_CurMinFrmCount++; if (m_CurMinFrmCount > m_MaxFrameCount) { //检测到帧率过低，可以做切换品质的功能 } } /// <summary> /// 绘制FPS /// </summary> private void OnGUI() { if (m_IsShowFPS) { var fpsStr = $"FPS:{m_CurShowFPS}"; GUI.Label(new Rect(0, 0, 100, 20), fpsStr); } } #endregion}以上代码中，FPSUtils类继承自MonoBehaviour，用于实现FPS统计和显示。
首先，定义了一个静态的CreateInstance方法，用于创建一个FPSUtils实例。在该方法中，首先判断是否已经存在一个FPSUtils实例，如果存在则直接返回。如果不存在，则创建一个新的GameObject对象，并将FPSUtils组件添加到该对象上。如果指定了parent参数，则将新创建的对象设置为该parent对象的第一个子对象，否则将其设置为不会被销毁的对象。
然后，定义了一个静态的DestroyInstance方法，用于销毁FPSUtils实例。在该方法中，首先判断是否存在FPSUtils实例，如果存在则销毁该实例，并将其设置为null。
接下来，定义了一些用于FPS统计的变量，包括是否显示FPS、帧数计算刷新时间、当前时间、当前帧数、临时FPS、帧数变化比较容忍度、当前FPS、当前显示的帧数、品质当前时间、品质的容忍度、帧数容忍度、最小FPS容忍度、当前最小帧数等。
然后，在Update方法中，每帧更新当前时间、帧数和当前FPS。如果当前时间超过了帧数计算刷新时间，则计算当前显示的帧数，并将临时FPS设置为当前显示的帧数。在计算当前显示的帧数时，如果当前显示的帧数与临时FPS的差值超过了帧数变化比较容忍度，则将临时FPS设置为当前显示的帧数，并将当前时间和帧数重置为0。
在FixedUpdate方法中，每帧更新品质当前时间和当前最小帧数。如果当前FPS大于等于最小FPS，则直接返回。如果当前FPS小于最小FPS，则将当前最小帧数加1。如果当前最小帧数超过了帧数容忍度，则可以做一些切换品质的功能。
最后，在OnGUI方法中，如果需要显示FPS，则绘制当前显示的帧数。
]]>在PyQt5中，我们经常需要在widget中添加label来显示文本信息。但是，由于文本长度和label大小的不确定性，有时候会出现文本显示不全或者字体过小难以阅读的问题。本文将介绍如何使用Python编写脚本来实现label的自适应大小。
对于单行文本，我们可以使用以下脚本来实现自适应大小：
def AutoSingleLabelFontSize(label): # 创建一个QFont对象 font = label.font() # 计算字体大小的范围 fm = QFontMetrics(font) min_size = 1 max_size = 20 # 二分查找适应的字体大小 low, high = min_size, max_size while low <= high: mid = (low + high) // 2 font.setPointSize(mid) fm = QFontMetrics(font) rect = fm.boundingRect(label.text()) if rect.width() <= label.width(): low = mid + 1 else: high = mid - 1 # 设置QLabel的字体 font.setPointSize(high) label.setFont(font)这个脚本使用二分查找来适应字体大小。我们可以通过调整min_size和max_size参数来控制字体大小的范围。
对于多行文本，我们可以使用以下脚本来实现自适应大小：
def AutoMultipleLabelFontSize(label): # 创建一个QFont对象 font = label.font() # 计算字体大小的范围 fm = QFontMetrics(font) min_size = 1 max_size = 20 # 二分查找适应的字体大小 low, high = min_size, max_size while low <= high: mid = (low + high) // 2 font.setPointSize(mid) fm = QFontMetrics(font) rect = fm.boundingRect(label.rect(), Qt.TextWordWrap, label.text()) if rect.width() <= label.width() and rect.height() <= label.height(): low = mid + 1 else: high = mid - 1 # 设置QLabel的字体 font.setPointSize(high) label.setFont(font)这个脚本与单行文本的脚本类似，但是我们可以通过word_wrap参数来控制文本是否自动换行。
以上就是使用Python编写的label自适应大小的脚本。希望这篇文章能够帮助您解决label大小自适应的问题。
]]>Hexo 博客中使用的图床无法访问，经查询是图床拦截问题，需要修改 referrer 信息。
找到博客文件中的 head.ejs 或 header.ejs，路径一般在 {博客路径}\themes\3-hexo\layout_partial\ 下。
在
标签中添加以下代码：这将禁用 referrer 信息，从而绕过图床的防盗链限制。
通过以上优化，可以使文章更加清晰易懂，让读者更容易理解和操作。
]]>
同样的方法搜索PyQt5-tool这个库进行安装即可
在终端中输入以下两个命令即可安装对应的库：
pip install pyqt5 pip install pyqt5-tool Name: 自己随便起个名字，一般都是QT Designer
Program: designer.exe软件所在的路径，路径位置一般为：{python路径}\Lib\site-packages\qt5_applications\Qt\bin\designer.exe
Working directory: $FileDir$
Name: 自己随便起个名字，一般都是配置PyUIC
Program: python.exe软件所在的路径，路径位置一般为：{python路径}\python.exe
Arguments: $FileName$ -o $FileNameWithoutExtension$.py
Working directory: $FileDir$
点击上图编号①就可以打开编辑界面 UI 的编辑器了，也可以使用快捷键 Ctrl + Alt + Shift + D
制作好界面后，在 PyCharm 中选中刚才制作的 UI 文件，右键 -> External Tools -> PyUIC 即可生成对应的代码。
这是一个管理Unity宏设置的脚本工具，能快速的增删改查项目的脚本。
下面是效果图：
/// <summary>/// 资源路径/// </summary>public static class ResCatalog{ public const string DefaultRes = "Library/unity default resources"; public const string Temporary = "Assets/_Temporary"; public const string Library = "Assets/_Library";}/// <summary>/// 构建的辅助工具/// </summary>public class BuildTargetUtility{ /// <summary> /// 获取对应平台的组 /// </summary> /// <param name="p"></param> /// <returns></returns> public static BuildTargetGroup PlatformToGroup(RuntimePlatform p) { return p switch { RuntimePlatform.OSXEditor => BuildTargetGroup.Standalone, RuntimePlatform.OSXPlayer => BuildTargetGroup.Standalone, RuntimePlatform.WindowsPlayer => BuildTargetGroup.Standalone, RuntimePlatform.WindowsEditor => BuildTargetGroup.Standalone, RuntimePlatform.IPhonePlayer => BuildTargetGroup.iOS, RuntimePlatform.Android => BuildTargetGroup.Android, RuntimePlatform.LinuxPlayer => BuildTargetGroup.Standalone, RuntimePlatform.LinuxEditor => BuildTargetGroup.Standalone, RuntimePlatform.WebGLPlayer => BuildTargetGroup.WebGL, RuntimePlatform.PS4 => BuildTargetGroup.PS4, RuntimePlatform.XboxOne => BuildTargetGroup.XboxOne, RuntimePlatform.tvOS => BuildTargetGroup.tvOS, RuntimePlatform.Switch => BuildTargetGroup.Switch, _ => BuildTargetGroup.Unknown }; }}/// <summary>/// 资源的Library/// </summary>public static class AssetLibrary{ /// <summary> /// 判断文件是否存在 /// </summary> /// <param name="path"></param> /// <param name="temporary"></param> /// <returns></returns> public static bool Exists(string path, bool temporary) { return File.Exists(GetPath(path, temporary)); } /// <summary> /// 获取文件的地址 /// </summary> /// <param name="path">文件名字</param> /// <param name="temporary">是否是临时文件</param> /// <returns></returns> public static string GetPath(string path, bool temporary) { return Path.Combine(temporary ? ResCatalog.Temporary : ResCatalog.Library, path); } /// <summary> /// 保存文件 /// </summary> /// <param name="path">文件地址</param> /// <param name="text">文件内容</param> /// <param name="temporary">是否是临时文件</param> public static void Save(string path, string text, bool temporary) { WriteAllText(path, text, temporary); } /// <summary> /// 保存文件 /// </summary> /// <param name="path">文件地址</param> /// <param name="bytes">写入的字节</param> /// <param name="temporary">是否是临时资源</param> public static void Save(string path, byte[] bytes, bool temporary) { WriteAllBytes(path, bytes, temporary); } /// <summary> /// 获取文件内的所有内容 /// </summary> /// <param name="path">文件地址</param> /// <param name="temporary">是否是临时文件</param> /// <returns></returns> public static string GetString(string path, bool temporary) { return File.ReadAllText(GetPath(path, temporary)); } /// <summary> /// 获取文件的所有字节 /// </summary> /// <param name="path">文件地址</param> /// <param name="temporary">是否是临时资源</param> /// <returns></returns> public static byte[] GetBytes(string path, bool temporary) { return File.ReadAllBytes(GetPath(path, temporary)); } /// <summary> /// 写入所有的字节 /// </summary> /// <param name="path">文件路径</param> /// <param name="bytes">写入字节</param> /// <param name="temporary">是否是临时资源</param> private static void WriteAllBytes(string path, byte[] bytes, bool temporary) { var realPath = GetPath(path, temporary); PathUtils.MakeDirectory(realPath); File.WriteAllBytes(realPath, bytes); } /// <summary> /// 写入所有的文本内容 /// </summary> /// <param name="path">文件路径</param> /// <param name="text">写入字符串</param> /// <param name="temporary">是否是临时资源</param> private static void WriteAllText(string path, string text, bool temporary) { var realPath = GetPath(path, temporary); PathUtils.MakeDirectory(realPath); File.WriteAllText(realPath, text); }}/// <summary>/// 宏的辅助工具/// </summary>public static class SymbolsUtility{ /// <summary> /// 设置宏 /// </summary> /// <param name="symbols"></param> public static void SetSymbols(params string[] symbols) { var result = string.Join(";", symbols); PlayerSettings.SetScriptingDefineSymbolsForGroup(BuildTargetGroup.Standalone, result); PlayerSettings.SetScriptingDefineSymbolsForGroup(BuildTargetGroup.iOS, result); PlayerSettings.SetScriptingDefineSymbolsForGroup(BuildTargetGroup.Android, result); } /// <summary> /// 获取所有的宏 /// </summary> /// <returns></returns> public static string[] GetSymbols() { var group = BuildTargetUtility.PlatformToGroup(Application.platform); var symbols = PlayerSettings.GetScriptingDefineSymbolsForGroup(group); return symbols.Split(';'); } /// <summary> /// 增加宏 /// </summary> /// <param name="symbols">宏的组</param> public static void AddSymbols(params string[] symbols) { SetSymbols(GetSymbols().Union(symbols).ToArray()); } /// <summary> /// 移除宏 /// </summary> /// <param name="symbols">宏的组</param> public static void RemoveSymbols(params string[] symbols) { SetSymbols(GetSymbols().Except(symbols).ToArray()); } /// <summary> /// 判断是否拥有宏 /// </summary> /// <param name="symbol">宏的名字</param> /// <returns></returns> public static bool HasSymbols(string symbol) { return -1 != Array.IndexOf(GetSymbols(), symbol); }}internal class SymbolsManager : EditorWindow{ /// <summary> /// 宏的配置 /// </summary> public class SymbolsConfig { /// <summary> /// 宏的名字 /// </summary> public string name; /// <summary> /// 是否使用 /// </summary> [NonSerialized] public bool used; } /// <summary> /// 宏的组 /// </summary> public class SymbolsGroup { /// <summary> /// 组的名字 /// </summary> public string name; /// <summary> /// 组的宏列表 /// </summary> public List<SymbolsConfig> list; /// <summary> /// 用于显示的List /// </summary> [NonSerialized] public ReorderableList reorderableList; /// <summary> /// 是否已经删除 /// </summary> [NonSerialized] public bool deleted; } /// <summary> /// 组的列表 /// </summary> private List<SymbolsGroup> m_Groups; /// <summary> /// 宏管理窗口 /// </summary> [MenuItem("Tools/SymbolsManager", false)] private static void OpenWindow() { var window = GetWindow<SymbolsManager>("SymbolsManager"); window.minSize = new Vector2(350, 100); } private void OnEnable() { var path = GetSettingsFileName(); if (AssetLibrary.Exists(path, false)) { var text = AssetLibrary.GetString(path, false); JsonUtils.ToObject(text, out m_Groups); foreach (var group in m_Groups) { if (null == group.list) { group.list = new List<SymbolsConfig>(); } else { foreach (var config in group.list) { config.used = SymbolsUtility.HasSymbols(config.name); } } } } m_Groups ??= new List<SymbolsGroup>(); } /// <summary> /// 绘制面板 /// </summary> private void OnGUI() { for (var i = 0; i < m_Groups.Count;) { var group = m_Groups[i]; GUILayout.BeginVertical(EditorStyles.helpBox); { if (null == group.reorderableList) { group.list ??= new List<SymbolsConfig>(); group.reorderableList = new ReorderableList(group.list, typeof(SymbolsConfig)) { drawHeaderCallback = rect => { var textRt = rect; textRt.width /= 2f; group.name = EditorGUI.TextField(textRt, group.name, EditorStyles.boldLabel); var btnRt = rect; btnRt.x = btnRt.xMax - Styles.closeButton.lineHeight; if (GUI.Button(btnRt, GUIContent.none, Styles.closeButton)) { if (EditorUtility.DisplayDialog( "提示", "是否确认删除?", "确认", "取消")) { group.deleted = true; } } }, drawElementCallback = (rect, index, active, focused) => { var item = group.list[index]; var textRect = new Rect( rect.position + Vector2.up * 2, new Vector2(rect.width - 100, EditorGUIUtility.singleLineHeight)); item.name = GUI.TextField(textRect, item.name)?.Trim(); const int btnWidth = 80; var oldColor = GUI.color; GUI.color = SymbolsUtility.HasSymbols(item.name) ? Color.green : Color.red; var btnRect = new Rect( rect.position + Vector2.up + Vector2.right * (rect.width - btnWidth), new Vector2(btnWidth, EditorGUIUtility.singleLineHeight)); item.used = GUI.Toggle(btnRect, item.used, item.used ? Styles.used : Styles.unused, EditorStyles.toolbarButton); GUI.color = oldColor; }, elementHeight = 22, }; } group.reorderableList.DoLayoutList(); GUILayout.BeginHorizontal(); GUILayout.FlexibleSpace(); if (GUILayout.Button(Styles.apply, GUILayout.Height(30), GUILayout.Width(100))) { foreach (var config in group.list) { if (config.used) { SymbolsUtility.AddSymbols(config.name); } else { SymbolsUtility.RemoveSymbols(config.name); } } AssetDatabase.SaveAssets(); AssetDatabase.Refresh(); } GUILayout.FlexibleSpace(); GUILayout.EndHorizontal(); GUILayout.Space(5); } GUILayout.EndVertical(); if (group.deleted) { m_Groups.RemoveAt(i); } else { ++i; } } // GUILayout.BeginHorizontal(); GUILayout.FlexibleSpace(); if (GUILayout.Button(Styles.addGroup, GUILayout.Height(30), GUILayout.Width(200))) { m_Groups.Add(new SymbolsGroup { name = Styles.customName, list = new List<SymbolsConfig>() }); } GUILayout.FlexibleSpace(); GUILayout.EndHorizontal(); var e = Event.current; if (e.keyCode == KeyCode.S && e.type == EventType.KeyUp) { e.Use(); Save(); } } /// <summary> /// 销毁的时候保存 /// </summary> private void OnDisable() { Save(); } /// <summary> /// 保存 /// </summary> private void Save() { JsonResolver.NotSerializeDefault = true; var text = JsonUtils.ToPrettyString(m_Groups); AssetLibrary.Save(GetSettingsFileName(), text, false); JsonResolver.NotSerializeDefault = false; } /// <summary> /// 序列化Json文件的名字，采用 “类名Settings.json”格式 /// </summary> /// <returns></returns> private string GetSettingsFileName() { return $"{GetType().Name}Settings.json"; } #region 显示风格Style /// <summary> /// 编辑器的风格 /// </summary> private static class Styles { /// <summary> /// 已经使用 /// </summary> public static GUIContent used; /// <summary> /// 未使用 /// </summary> public static GUIContent unused; /// <summary> /// 应用 /// </summary> public static GUIContent apply; /// <summary> /// 新增分组 /// </summary> public static GUIContent addGroup; /// <summary> /// 自定义名称(点击修改) /// </summary> public static string customName; /// <summary> /// WinBtnClose /// </summary> public static GUIStyle closeButton; static Styles() { used = new GUIContent("已使用"); unused = new GUIContent("未使用"); apply = new GUIContent("应用"); addGroup = new GUIContent("新增分组"); customName = "自定义名称(点击修改)"; closeButton = new GUIStyle("WinBtnClose"); } } #endregion}一个辅助快速生成需要的C#脚本的脚本。主要是快速生成引用，命名空间，类和方法一些。
public class ScriptBuilder{ /// <summary> /// 脚本的字符串 /// </summary> private StringBuilder m_Builder = new StringBuilder(); /// <summary> /// 空白地字符串 /// </summary> private StringBuilder m_Blank = new StringBuilder(); /// <summary> /// 用于判断是否在方法内生成脚本 /// </summary> public bool MarkInMethod { get; set; } /// <summary> /// 增加一行数据 /// </summary> /// <param name="message"></param> public void AppendLine(string message) { m_Builder.Append(m_Blank); m_Builder.AppendLine(message); } /// <summary> /// 开始增加空白 /// </summary> private void BeginBlank() { m_Blank.Append('\t'); } /// <summary> /// 结束增加空白 /// </summary> private void EndBlank() { m_Blank.Remove(m_Blank.Length - 1, 1); } /// <summary> ///开始增加命名空间 /// </summary> /// <param name="name">命名空间的名字</param> public void BeginNamespace(string name) { BeginBrace($"namespace {name}"); } /// <summary> /// 结束增加命名空间 /// </summary> public void EndNamespace() { EndBrace(); } /// <summary> /// 开始增加类 /// </summary> /// <param name="modifier">类的修饰字符串</param> /// <param name="className">类的名字</param> /// <param name="superclass">继承类的名字</param> public void BeginClass(string modifier, string className, string superclass) { BeginBrace($"public {modifier} class {className} : {superclass}"); } /// <summary> /// 开始增加类 /// </summary> /// <param name="modifier">类的修饰字符串</param> /// <param name="className">类的名字</param> public void BeginClass(string modifier, string className) { BeginBrace($"public {modifier} class {className}"); } /// <summary> /// 开始增加类 /// </summary> /// <param name="className">类的名字</param> public void BeginClass(string className) { BeginBrace($"public class {className}"); } /// <summary> /// 结束类 /// </summary> public void EndClass() { EndBrace(); } /// <summary> /// 开始增加方法 /// </summary> /// <param name="method">方法名</param> /// <param name="permission">访问权限</param> /// <param name="returnType">返回类型</param> /// <param name="modifier">修饰符</param> public void BeginMethod(string method, string permission = "public", string returnType = "void", string modifier = "") { MarkInMethod = true; BeginBrace(string.IsNullOrEmpty(modifier) ? $"{permission} {returnType} {method}" : $"{permission} {modifier} {returnType} {method}"); } /// <summary> /// 结束方法 /// </summary> public void EndMethod() { EndBrace(); MarkInMethod = false; } /// <summary> /// 开始属性 /// </summary> /// <param name="property">属性名字</param> public void BeginProperty(string property) { BeginBrace(property); } /// <summary> /// 结束属性 /// </summary> public void EndProperty() { EndBrace(); } /// <summary> /// 大括号的开始 /// </summary> /// <param name="code"></param> public void BeginBrace(string code) { AppendLine($"{code}"); AppendLine("{"); BeginBlank(); } /// <summary> /// 结束大括号 /// </summary> public void EndBrace() { EndBlank(); AppendLine("}"); } /// <summary> /// 开始字段 /// </summary> /// <param name="code">Field的名字</param> public void BeginField(string code) { AppendLine($"{code}"); AppendLine("{"); BeginBlank(); } /// <summary> /// 结束字段 /// </summary> public void EndField() { EndBlank(); AppendLine("};"); } /// <summary> /// 开始Region /// </summary> /// <param name="name">Region的名字</param> public void BeginRegion(string name) { AppendLine($"#region {name}"); } /// <summary> /// 结束Region /// </summary> public void EndRegion() { AppendLine("#endregion"); } /// <summary> /// 转成字符串 /// </summary> /// <returns></returns> public override string ToString() { return m_Builder.ToString(); }}上述方法就是辅助的脚本，下面是举例调用方法作为参考
// 获取类脚本的路径var scriptPath = AssetDatabase.GUIDToAssetPath(kGUID);var sb = new ScriptBuilder();sb.BeginNamespace(typeof(StorageKeyConst).Namespace);sb.BeginClass("static", "StorageKeyConst");if (DataStorageEditorTools.Instance.DataStorageEditorDataRootList.Count > 0){ sb.BeginRegion("RootKeys"); sb.AppendLine(string.Empty); AddListScripts(sb, DataStorageEditorTools.Instance.DataStorageEditorDataRootList); sb.AppendLine(string.Empty); sb.EndRegion(); sb.AppendLine(string.Empty);}if (DataStorageEditorTools.Instance.DataStorageEditorDataList.Count > 0){ sb.BeginRegion("Keys"); sb.AppendLine(string.Empty); AddListScripts(sb, DataStorageEditorTools.Instance.DataStorageEditorDataList); sb.AppendLine(string.Empty); sb.EndRegion();}sb.EndClass();sb.EndNamespace();File.WriteAllText(scriptPath, sb.ToString(), Encoding.UTF8);AssetDatabase.SaveAssets();AssetDatabase.Refresh();在游戏开发中，美术人员有时需要将一些数字转换为罗马数字。本文介绍了一种将阿拉伯数字转换为罗马数字的方法，可以帮助美术人员快速完成转换。如果您是游戏开发人员或对数字转换感兴趣，本文也会对您有所帮助。
/// <summary>/// 数字转罗马数字/// </summary>/// <param name="num"></param>/// <returns></returns>public static string IntToRoman(int num){ var res = string.Empty; var val = new List<int> { 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1 }; var str = new List<string> { "M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I" }; for(var i = 0;i < val.Count; ++i) { while(num >= val[i]) { num -= val[i]; res += str[i]; } } return res;}在用编辑器开发工具的时候，我们经常会用到折叠的Foldout，这里就不对Foldout做详细的介绍了，本文主要分享如何对Foldout做一个扩展，笔者在开发中常常需要的一个右键菜单的功能，这样我们就可以添加很多功能而不需要增加按钮，右键选择对应的菜单就行了。
var rect = GUILayoutUtility.GetRect(EditorGUIUtility.fieldWidth, EditorGUIUtility.fieldWidth, 18f, 18f, EditorStyles.foldout);m_IsFoldout = EditorGUI.Foldout(rect, m_IsFoldout, "标题");CreateNewGenericMenu(rect, new List<string> { "方法一", "方法二", "方法三" }, new List<Action>{ (() => {Debug.LogError("1");}), (() => {Debug.LogError("2");}), (() => {Debug.LogError("3");}),});/// <summary>/// 绘制右键菜单/// </summary>/// <param name="btnRect"></param>/// <param name="menuName"></param>/// <param name="menuIsOn"></param>/// <param name="menuCallBack"></param>/// <returns></returns>public GenericMenu CreateNewGenericMenu(Rect btnRect, List<string> menuName, List<Action> menuCallBack, List<bool> menuIsOn = null){ var menu = new GenericMenu(); var index = 0; foreach (var action in menuCallBack) { menu.AddItem(new GUIContent(menuName[index]), menuIsOn != null && menuIsOn[index], () => { action?.Invoke(); }); index++; } if (Event.current.button == 1 && Event.current.type == EventType.MouseDown && btnRect.Contains(Event.current.mousePosition)) { menu.ShowAsContext(); } return menu;}当UI打开一个小的提示tip的时候，常见的需求是点击其他任意地方就关闭tip，这个功能很常见，空白出响应点击，监听到就关闭tip，这里会发现一个问题，我们并不能响应tip面板底下的其他按钮，这样玩家在操作的时候就需要先关掉tip，然后再点一下按钮，这往往不是策划想要的，所以我们需要在点击空白处关闭的时候同时响应底下的按钮，这个时候就需要点击穿透事件。
using System.Collections.Generic;using UnityEngine;using UnityEngine.EventSystems;namespace ZHEngine.UI{ public sealed class UTouchPass : MonoBehaviour, IPointerClickHandler, IMoveHandler,IPointerDownHandler, IPointerUpHandler,IPointerEnterHandler,ISelectHandler, IDeselectHandler , ISubmitHandler, IInitializePotentialDragHandler, IBeginDragHandler, IEndDragHandler, IDragHandler, IScrollHandler { private GameObject CacheGameObject; private readonly List<RaycastResult> result = new List<RaycastResult>(); public void OnPointerClick(PointerEventData eventData) { PassEvent(eventData, ExecuteEvents.pointerClickHandler); } public void OnPointerDown(PointerEventData eventData) { PassEvent(eventData, ExecuteEvents.pointerDownHandler); if (Input.GetButtonDown("Submit")) ExecuteEvents.Execute(eventData.pointerCurrentRaycast.gameObject, eventData, ExecuteEvents.submitHandler); } public void OnPointerUp(PointerEventData eventData) { PassEvent(eventData, ExecuteEvents.pointerUpHandler); } public void OnPointerEnter(PointerEventData eventData) { PassEvent(eventData, ExecuteEvents.pointerEnterHandler); } public void OnSelect(BaseEventData eventData) { PassEvent(eventData, ExecuteEvents.selectHandler); } public void OnDeselect(BaseEventData eventData) { PassEvent(eventData, ExecuteEvents.deselectHandler); } public void OnSubmit(BaseEventData eventData) { PassEvent(eventData, ExecuteEvents.submitHandler); } public void OnMove(AxisEventData eventData) { PassEvent(eventData, ExecuteEvents.moveHandler); } public void OnInitializePotentialDrag(PointerEventData eventData) { CacheGameObject = PassEvent(eventData, ExecuteEvents.initializePotentialDrag); } public void OnBeginDrag(PointerEventData eventData) { PassEvent(eventData, ExecuteEvents.beginDragHandler); } public void OnDrag(PointerEventData eventData) { ExecuteEvents.Execute(CacheGameObject, eventData, ExecuteEvents.dragHandler); } public void OnEndDrag(PointerEventData eventData) { ExecuteEvents.Execute(CacheGameObject, eventData, ExecuteEvents.endDragHandler); CacheGameObject = null; } public void OnScroll(PointerEventData eventData) { ExecuteEvents.Execute(CacheGameObject, eventData, ExecuteEvents.scrollHandler); } private GameObject PassEvent<T>(BaseEventData data, ExecuteEvents.EventFunction<T> function) where T : IEventSystemHandler { if (data is PointerEventData eventData) { var pointerGo = eventData.pointerCurrentRaycast.gameObject ? eventData.pointerCurrentRaycast.gameObject : eventData.pointerDrag; EventSystem.current.RaycastAll(eventData, result); foreach (var item in result) { var go = item.gameObject; if (go != null && go != pointerGo) { var executeGo = ExecuteEvents.GetEventHandler<T>(go); if (executeGo) { if (executeGo.TryGetComponent<UTouchPass>(out var __)) return null; ExecuteEvents.Execute(executeGo, data, function); return executeGo; } else { if(go.TryGetComponent<UnityEngine.UI.Graphic>(out var com)) { if (com.raycastTarget) return null; } } } } } return null; } }}游戏编辑器工具开发中会经常遇到下拉菜单的需求，笔者也遇到了一种特殊的下拉菜单，是下拉后可以多选的菜单，于是笔者便记录下这种特殊菜单的开发脚本。
public enum DropdownMultiType{ [InspectorName("无")] None = 0, Everything = ~0, [InspectorName("类型一")] Type1 = 1 << 1, [InspectorName("类型二")] Type2 = 1 <<2, [InspectorName("类型三")] Type3 = 1<<3}m_DropdownMultiType = (DropdownMultiType)EditorGUILayout.EnumFlagsField(m_DropdownMultiType, GUILayout.Width(120))；EditorGUILayout.LabelField($"Type1：{m_DropdownMultiType.HasFlag(DropdownMultiType.Type1)}");EditorGUILayout.LabelField($"Type2：{m_DropdownMultiType.HasFlag(DropdownMultiType.Type2)}");EditorGUILayout.LabelField($"Type3：{m_DropdownMultiType.HasFlag(DropdownMultiType.Type3)}");Unity打包经常会用一些文件的复制粘贴到一些文件到自己指定的SDK目录，一开始我们使用的是bat脚本，但是笔者发现这个脚本没办法在打包机（MAC）上使用，于是笔者便想到了python脚本来实现。
import sysimport osimport jsonimport shutil{ "remdir":[ "data/libs/", "data/src/main/assets/" ], "copydir":[ "../xarchive/android/unityLibrary/libs/", "../xarchive/android/unityLibrary/ ]}if (len(sys.argv) > 1): isPAD = sys.argv[1]if(isPAD == "0") ...命令执行python脚本的时候通过读取sys.argv便可以读取到自己传入的参数，这里需要注意的是读取的都是字符串，所以笔者在读数字0的时候需要用到**”0”**。
configFilePath = "config.json";with open(configFilePath,'r') as load_f: load_dict = json.load(load_f)def path_remove(removepath): for remdirPath in removepath: try: if os.path.exists(remdirPath): if os.path.isdir(remdirPath): shutil.rmtree(remdirPath) else: os.remove(remdirPath) print("Remove Success: "+remdirPath) except OSError as e: print("Error: %s : %s" % (remdirPath, e.strerror))def proc_copy(old_path, new_path): if os.path.exists(old_path): if os.path.isdir(old_path): shutil.copytree(old_path, new_path) elif os.path.isfile(old_path): shutil.copyfile(old_path, new_path) print("Copy Success: " + old_path) else: print("NOT FOUND: {}".format(old_path))def path_copy(copydir, pastedir): for index in range(len(copydir)): if os.path.exists(pastedir[index]): if os.path.isdir(pastedir[index]): shutil.rmtree(pastedir[index]) proc_copy(copydir[index],pastedir[index])获取设备唯一标识的方法。
引用库的github地址：Android_CN_OAID
在Android最外层的bundel.gradle里添加下面依赖
allprojects { repositories { ''' maven { url 'https://www.jitpack.io' } ... }}在app或者library的bundel.gradle添加下面依赖
dependencies {implementation 'com.github.gzu-liyujiang:Android_CN_OAID:<version>'}在Application或者Active的onCreate里添加下面代码：
@Overridepublic void onCreate() { super.onCreate(); if (privacyPolicyAgreed) { ... DeviceIdentifier.register(<Application>); ... }}需要的变量：
//设备唯一标识private static String deviceId;//设备唯一标识文件名字private static String deviceIdFileName = "all_in_sdk";//设备唯一标识缓存关键字keyprivate static String deviceIdKey = "DeviceId";//设备唯一标识正则private static final Pattern ANDROID_ID_PATTERN = Pattern.compile("^[0-9a-fA-F]{16}$");获取的方法：
//获取设备的唯一标识public static String GetDeviceID() { if(m_Activity == null){ m_Activity = UnityPlayer.currentActivity; } Application application = m_Activity.getApplication(); if (application == null) return ""; if (deviceId != null) return deviceId; deviceId = getSPValue((Context)application, deviceIdKey); if (!TextUtils.isEmpty(deviceId)) return deviceId; deviceId = getAndroidIdAsDeviceId((Context)application); if (!TextUtils.isEmpty(deviceId)) { saveSPValue((Context)application, deviceIdKey, deviceId); return deviceId; } deviceId = generateSoftDeviceId(); if (!TextUtils.isEmpty(deviceId)) { saveSPValue((Context)application, deviceIdKey, deviceId); return deviceId; } return deviceId;}private static String getSPValue(Context paramContext, String paramString) { SharedPreferences sharedPreferences = paramContext.getSharedPreferences(deviceIdFileName, 0); return sharedPreferences.getString(paramString, null);}private static String getAndroidIdAsDeviceId(Context paramContext) { String str; if(DeviceID.supportedOAID(m_Activity)) { str = DeviceIdentifier.getOAID(m_Activity); if (isLegalAndroidId(str, true)) return str; } str = DeviceIdentifier.getAndroidID(m_Activity); if (isLegalAndroidId(str, true)) return str; str = DeviceIdentifier.getIMEI(m_Activity); if (isLegalAndroidId(str, true)) return str; str = DeviceIdentifier.getWidevineID(); if (isLegalAndroidId(str, true)) return str; str = DeviceIdentifier.getPseudoID(); if (isLegalAndroidId(str, true)) return str; str = DeviceIdentifier.getGUID(m_Activity); if (isLegalAndroidId(str, true)) return str; return null;}private static String generateSoftDeviceId() { String str1 = Build.SERIAL; String str2 = !TextUtils.isEmpty(str1) ? str1 : "NA"; try { long l1 = 1152921504606846976L; long l2 = randomLong(Long.MAX_VALUE - l1) + l1; return String.format("%1$s_%2$s", new Object[] { Long.toHexString(l2), str2 }); } catch (Throwable throwable) { return String.format("%1$s_%2$s", new Object[] { "NA" + Long.toHexString(System.currentTimeMillis()), str2 }); }}private static void saveSPValue(Context paramContext, String paramString1, String paramString2) { SharedPreferences sharedPreferences = paramContext.getSharedPreferences(deviceIdFileName, 0); sharedPreferences.edit().putString(paramString1, paramString2).apply();}private static long randomLong(long paramLong) { if (Build.VERSION.SDK_INT >= 21) return ThreadLocalRandom.current().nextLong(paramLong); return (long)((new Random()).nextDouble() * (paramLong - 1L));}private static boolean isLegalAndroidId(String paramString, boolean paramBoolean) { if (paramBoolean) return (!TextUtils.isEmpty(paramString) && ANDROID_ID_PATTERN .matcher(paramString).find()); return (!TextUtils.isEmpty(paramString) && ANDROID_ID_PATTERN .matcher(paramString).find());}在UI的开发过程中，经常会遇到Image随子节点的文字变化自动缩放，就是拿Image当背景。笔者遇到这种问题每次都是利用Layout+Content Size Fitter来完成的，笔者想了想每次都要加两个组件，并且Layout只用到了随自己点自适应的功能，于是笔者便想办法把两个功能合成一个脚本来实现需求，于是便有了下面的脚本。
代码如下：
using System;using UnityEngine;using UnityEngine.EventSystems;using UnityEngine.UI;/// <summary>/// 未完成，暂时别用/// </summary>[AddComponentMenu("Layout/Rect Transform Fitter", 142)][ExecuteAlways][RequireComponent(typeof(RectTransform))]public class RectTransformFit : UIBehaviour, ILayoutGroup{ [SerializeField] protected RectTransform m_RectChildren; [SerializeField] protected RectOffset m_Padding = new RectOffset(); [SerializeField] protected TextAnchor m_ChildAlignment = TextAnchor.UpperLeft; [SerializeField] protected bool m_ChildControlWidth = false; [SerializeField] protected bool m_ChildControlHeight = false; [SerializeField] protected ContentSizeFitter.FitMode m_HorizontalFit = ContentSizeFitter.FitMode.Unconstrained; [SerializeField] protected ContentSizeFitter.FitMode m_VerticalFit = ContentSizeFitter.FitMode.Unconstrained; public RectOffset padding { get => m_Padding; set => SetProperty(ref m_Padding, value); } public TextAnchor childAlignment { get => m_ChildAlignment; set => SetProperty(ref m_ChildAlignment, value); } public bool childControlWidth { get => m_ChildControlWidth; set => SetProperty(ref m_ChildControlWidth, value); } public bool childControlHeight { get => m_ChildControlHeight; set => SetProperty(ref m_ChildControlHeight, value); } public ContentSizeFitter.FitMode horizontalFit { get => m_HorizontalFit; set { if (SetPropertyUtility.SetStruct(ref m_HorizontalFit, value)) SetDirty(); } } public ContentSizeFitter.FitMode verticalFit { get => m_VerticalFit; set { if (SetPropertyUtility.SetStruct(ref m_VerticalFit, value)) SetDirty(); } } [NonSerialized] private RectTransform m_Rect; protected RectTransform rectTransform { get { if (m_Rect == null) m_Rect = GetComponent<RectTransform>(); return m_Rect; } }#pragma warning disable 649 private DrivenRectTransformTracker m_Tracker;#pragma warning restore 649 private void OnEnable() { m_Rect ??= GetComponent<RectTransform>(); SetDirty(); } protected override void OnRectTransformDimensionsChange() { SetDirty(); } protected override void OnDisable() { m_Tracker.Clear(); base.OnDisable(); } /// <summary> /// Calculate and apply the horizontal component of the size to the RectTransform /// </summary> public void SetLayoutHorizontal() { m_Tracker.Clear(); if (m_RectChildren == null || !m_ChildControlWidth) { SetDirty(); return; } HandleSelfFittingAlongAxis(0, m_RectChildren); } /// <summary> /// Calculate and apply the vertical component of the size to the RectTransform /// </summary> public void SetLayoutVertical() { if (m_RectChildren == null || !m_ChildControlHeight) { SetDirty(); return; } HandleSelfFittingAlongAxis(1, m_RectChildren); } private void HandleSelfFittingAlongAxis(int axis, RectTransform rectChild) { if (rectChild == null) return; var fitting = (axis == 0 ? horizontalFit : verticalFit); if (fitting == ContentSizeFitter.FitMode.Unconstrained) { // Keep a reference to the tracked transform, but don't control its properties: m_Tracker.Add(this, rectChild, DrivenTransformProperties.None); return; } m_Tracker.Add(this, rectChild, (axis == 0 ? DrivenTransformProperties.SizeDeltaX : DrivenTransformProperties.SizeDeltaY)); // Set size to min or preferred size rectChild.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, fitting == ContentSizeFitter.FitMode.MinSize ? LayoutUtility.GetMinSize(rectChild, axis) : LayoutUtility.GetPreferredSize(rectChild, axis)); SetDirty(); } /// <summary> /// Helper method used to set a given property if it has changed. /// </summary> /// <param name="currentValue">A reference to the member value.</param> /// <param name="newValue">The new value.</param> protected void SetProperty<T>(ref T currentValue, T newValue) { if ((currentValue == null && newValue == null) || (currentValue != null && currentValue.Equals(newValue))) return; currentValue = newValue; SetDirty(); } protected void SetDirty() { if (!IsActive()) return; RefreshRect(); LayoutRebuilder.MarkLayoutForRebuild(m_RectChildren); LayoutRebuilder.MarkLayoutForRebuild(m_Rect); } public void RefreshRect() { if (m_RectChildren == null) return; Vector2 anchoredPos; var childSize = m_RectChildren.sizeDelta; var width = childSize.x + padding.left + padding.right; var height = childSize.y + padding.top + padding.bottom; var rectSize = rectTransform.sizeDelta; if (horizontalFit != ContentSizeFitter.FitMode.Unconstrained && verticalFit != ContentSizeFitter.FitMode.Unconstrained) { rectTransform.sizeDelta = new Vector2(width, height); } else if (horizontalFit != ContentSizeFitter.FitMode.Unconstrained) { rectTransform.sizeDelta = new Vector2(width, rectSize.y); } else if (verticalFit != ContentSizeFitter.FitMode.Unconstrained) { rectTransform.sizeDelta = new Vector2(rectSize.x, height); } rectSize = rectTransform.sizeDelta; var oldPos = rectTransform.anchoredPosition; var oldPivot = rectTransform.pivot; switch (m_ChildAlignment) { case TextAnchor.UpperLeft: rectTransform.pivot = new Vector2(0, 1); anchoredPos = new Vector2(padding.left, -padding.top); break; case TextAnchor.UpperCenter: rectTransform.pivot = new Vector2(0.5f, 1); anchoredPos = new Vector2(0, -padding.top); break; case TextAnchor.UpperRight: rectTransform.pivot = new Vector2(1, 1); anchoredPos = new Vector2(-padding.right, -padding.top); break; case TextAnchor.MiddleLeft: rectTransform.pivot = new Vector2(0, 0.5f); anchoredPos = new Vector2(padding.left, 0); break; case TextAnchor.MiddleCenter: rectTransform.pivot = new Vector2(0.5f, 0); anchoredPos = new Vector2(0, 0); break; case TextAnchor.MiddleRight: rectTransform.pivot = new Vector2(1, 0); anchoredPos = new Vector2(-padding.right, 0); break; case TextAnchor.LowerLeft: rectTransform.pivot = new Vector2(0, 0); anchoredPos = new Vector2(padding.left, padding.bottom); break; case TextAnchor.LowerCenter: rectTransform.pivot = new Vector2(0.5f, 0); anchoredPos = new Vector2(0, padding.bottom); break; case TextAnchor.LowerRight: rectTransform.pivot = new Vector2(1, 0); anchoredPos = new Vector2(-padding.right, padding.bottom); break; default: throw new ArgumentOutOfRangeException(); } var pivot = rectTransform.pivot; rectTransform.anchoredPosition = new Vector2(oldPos.x + rectSize.x * (pivot.x - oldPivot.x), oldPos.y + rectSize.y * (pivot.y - oldPivot.y)); m_RectChildren.anchorMax = pivot; m_RectChildren.anchorMin = pivot; m_RectChildren.pivot = pivot; m_RectChildren.anchoredPosition = anchoredPos; }#if UNITY_EDITOR protected override void OnValidate() { SetDirty(); }#endif}using System;using System.Collections.Generic;using UnityEngine;internal static class SetPropertyUtility{ private const float Tolerance = 0.000001f; //通过此值判断值是否发生变化 public static bool SetColor(ref Color currentValue, Color newValue) { if (Math.Abs(currentValue.r - newValue.r) < Tolerance && Math.Abs(currentValue.g - newValue.g) < Tolerance && Math.Abs(currentValue.b - newValue.b) < Tolerance && Math.Abs(currentValue.a - newValue.a) < Tolerance) return false; currentValue = newValue; return true; } public static bool SetStruct<T>(ref T currentValue, T newValue) where T : struct { if (EqualityComparer<T>.Default.Equals(currentValue, newValue)) return false; currentValue = newValue; return true; } public static bool SetClass<T>(ref T currentValue, T newValue) where T : class { if ((currentValue == null && newValue == null) || (currentValue != null && currentValue.Equals(newValue))) return false; currentValue = newValue; return true; }}代码如下：
using System;using UnityEditor;using UnityEditor.UI;using UnityEngine;[CustomEditor(typeof(RectTransformFit))]public class RectTransformFitEditor : SelfControllerEditor{ SerializedProperty m_Padding; SerializedProperty m_ChildAlignment; SerializedProperty m_RectChildren; SerializedProperty m_HorizontalFit; SerializedProperty m_VerticalFit; SerializedProperty m_ChildControlWidth; SerializedProperty m_ChildControlHeight; protected void OnEnable() { m_Padding = serializedObject.FindProperty("m_Padding"); m_ChildAlignment = serializedObject.FindProperty("m_ChildAlignment"); m_RectChildren = serializedObject.FindProperty("m_RectChildren"); m_ChildControlWidth = serializedObject.FindProperty("m_ChildControlWidth"); m_ChildControlHeight = serializedObject.FindProperty("m_ChildControlHeight"); m_HorizontalFit = serializedObject.FindProperty("m_HorizontalFit"); m_VerticalFit = serializedObject.FindProperty("m_VerticalFit"); } public override void OnInspectorGUI() { serializedObject.Update(); EditorGUILayout.PropertyField(m_Padding, true); EditorGUILayout.PropertyField(m_ChildAlignment, true); EditorGUILayout.PropertyField(m_RectChildren, true); Rect rect = EditorGUILayout.GetControlRect(); rect = EditorGUI.PrefixLabel(rect, -1, EditorGUIUtility.TrTextContent("Control Child Size")); rect.width = Mathf.Max(50, (rect.width - 4) / 3); EditorGUIUtility.labelWidth = 50; ToggleLeft(rect, m_ChildControlWidth, EditorGUIUtility.TrTextContent("Width")); rect.x += rect.width + 2; ToggleLeft(rect, m_ChildControlHeight, EditorGUIUtility.TrTextContent("Height")); EditorGUIUtility.labelWidth = 0; EditorGUILayout.PropertyField(m_HorizontalFit, true); EditorGUILayout.PropertyField(m_VerticalFit, true); serializedObject.ApplyModifiedProperties(); } void ToggleLeft(Rect position, SerializedProperty property, GUIContent label) { bool toggle = property.boolValue; EditorGUI.showMixedValue = property.hasMultipleDifferentValues; EditorGUI.BeginChangeCheck(); int oldIndent = EditorGUI.indentLevel; EditorGUI.indentLevel = 0; toggle = EditorGUI.ToggleLeft(position, label, toggle); EditorGUI.indentLevel = oldIndent; if (EditorGUI.EndChangeCheck()) { property.boolValue = property.hasMultipleDifferentValues || !property.boolValue; } EditorGUI.showMixedValue = false; }}今天更新自己博客的时候发现新博客的图片都无法显示，这个听说只存在于没有域名的博客中，笔者因为没有域名，所以不清除是不是。
图床：gitee
博客：github+hexo
原因猜测：gitee开始对图床进行限制，没有域名的博客也访问不到图床的图片
#解决方法
最快捷的解决方案就是再自己博客的文章开头加上下面代码
<meta name="referrer" content="no-referrer" />看下面举例
在自己播放的主题文件加里直接加上就不需要了，具体路径：
拿3-hexo主题举例：
在**…\themes\3-hexo\layout_partial\header.ejs**文件里加入刚才的代码，如下：
其他主题文件在类似位置：hexo\themes...\layout_partial\head.ejs
其他主题的文件名字应该叫：head.ejs。