GEngine

GEngine概述

GEngine，基于Unity引擎封装库，以我名字首字母命名。该库并不涉及引擎底层，主要是把游戏开发中所需要的东西整合起来而已。个人能力有限，错误或考虑不周在所难免，有任何疑问和建设性意见的请留言。方案调整或错误修复后，我会更新相关信息。

打包(GEngine.Packge.Gzip)

GEngine的打包库采用DotNetZip，结合了Nini进行配置，可在打包的时候配置不想打包的文件、文件夹，同时支持强行包含文件、文件夹。配置时，主要配置需要忽略打包的条件，如果忽略打包中有需要的再强制设置为打包包含。

源码与实例：

GZip类：

using System.Collections.Generic;
using System.IO;
using Nini.Config;
using Ionic.Zip;

namespace GEngine.Package
{
	public sealed class GZip 
	{
		bool openFilter ;																					//开启压缩过滤模式
		List<string> ignoreFiles_Extension = new List<string> ();					//压缩时，忽略扩展名类文件
		List<string> ignoreFiles_Name = new List<string>();							//压缩时，忽略文件名包含串文件
		List<string> ignoreFolders_Extension = new List<string> ();				//压缩时，忽略扩展名类文件夹
		List<string> ignoreFolders_Name = new List<string> ();						//压缩时，忽略文件夹名包含串文件夹

		List<string> containFiles_Extension = new List<string>();					//压缩时，强制包含扩展名类文件
		List<string> containFiles_Name = new List<string>();							//压缩时，强制包含文件名包含串文件
		List<string> containFolders_Extension = new List<string>();				//压缩时，强制包含扩展名类文件夹
		List<string> containFolders_Name = new List<string>();					//压缩时，强制包含文件夹名包含串文件夹

		static GZip zip;

		/// <summary>
		/// 获取GZip实例
		/// </summary>
		public static GZip Inst
		{
			get
			{
				if(zip == null)
				{
					zip = new GZip();
				}

				return zip;
			}
		}
		
		/// <summary>
		/// 初始化压缩、解压系统
		/// </summary>	
		public void OpenFilter(string filterFile)
		{	
			CloseFilter();			
			openFilter = true;

			IniConfigSource source = new IniConfigSource(filterFile);
			
			IConfig config = source.Configs["IgnoreFile_Extension"];
			string[] vls = config.GetValues();
			foreach(string vl in vls)
			{
				ignoreFiles_Extension.Add(vl);
			}
			config = source.Configs["IgnoreFile_Name"];
			vls = config.GetValues();
			foreach(string vl in vls)
			{
				ignoreFiles_Name.Add(vl);
			}
			
			config = source.Configs["IgnoreFolder_Extension"];
			vls = config.GetValues();
			foreach(string vl in vls)
			{
				ignoreFolders_Extension.Add(vl);
			}
			config = source.Configs["IgnoreFolder_Name"];
			vls = config.GetValues();
			foreach(string vl in vls)
			{
				ignoreFolders_Name.Add(vl);
			}

			config = source.Configs["ContainFile_Extension"];
			vls = config.GetValues();
			foreach(string vl in vls)
			{
				containFiles_Extension.Add(vl);
			}
			config = source.Configs["ContainFile_Name"];
			vls = config.GetValues();
			foreach(string vl in vls)
			{
				containFiles_Name.Add(vl);
			}

			config = source.Configs["ContainFolder_Extension"];
			vls = config.GetValues();
			foreach(string vl in vls)
			{
				containFolders_Extension.Add(vl);
			}
			config = source.Configs["ContainFolder_Name"];
			vls = config.GetValues();
			foreach(string vl in vls)
			{
				containFolders_Name.Add(vl);
			}
		}

		public void CloseFilter()
		{
			openFilter = false;

			ignoreFiles_Extension.Clear();
			ignoreFiles_Name.Clear();
			ignoreFolders_Extension.Clear();
			ignoreFolders_Name.Clear();
			
			containFiles_Extension.Clear();
			containFiles_Name.Clear();
			containFolders_Extension.Clear();
			containFolders_Name.Clear();
		}
		
		/// <summary>
		/// 压缩指定路径文件
		/// </summary>
		/// <param name="filePath">压缩源文件</param>
		/// <param name="savePath">压缩目标文件</param>
		public void Compress(string filePath, string savePath)
		{
			if(File.Exists(filePath) && !IsIgnoreFile(filePath))
			{
				using (ZipFile zip = new ZipFile())
				{
					zip.AddFile(filePath, "");
					zip.Save(savePath);
				}
			}
			else if(Directory.Exists(filePath) && !IsIgnoreFolder(filePath))
			{
				string[] files = Directory.GetFiles(filePath, "*", SearchOption.AllDirectories);
				if(files.Length < 1)
					return;
				
				using (ZipFile zip = new ZipFile())
				{
					foreach(string file in files)
					{
						if(IsIgnoreFile(file))
							continue;
						
						DirectoryInfo dicInfo = Directory.GetParent(file);
						if(IsIgnoreFolder(dicInfo.FullName))
							continue;
						
						if(dicInfo.FullName != filePath)
						{					
							zip.AddFile(file, dicInfo.Name);
						}
						else
						{
							zip.AddFile(file, "");
						}
					}
					zip.Save(savePath);
				}
			}
		}

		/// <summary>
		/// 解压指定路径文件
		/// </summary>
		/// <param name="filePath">解压源文件</param>
		/// <param name="savePath">解压目标文件</param>
		public void Decompress(string filePath, string savePath)
		{
			using (ZipFile zip = new ZipFile(filePath))
			{
					zip.ExtractAll(savePath);
			}
		}
		
		/// <summary>
		/// 忽略文件
		/// </summary>
		/// <returns><c>true</c> 被忽略返回; 否则返回, <c>false</c>.</returns>
		/// <param name="file">待检测文件</param>
		bool IsIgnoreFile(string file)
		{
			if (!openFilter)
				return false;

			string extension = Path.GetExtension(file);

			if(containFiles_Extension.Count > 0 && containFiles_Extension.Contains(extension))
				return false;

			if(containFiles_Name.Count > 0)
			{
				foreach(string containStr in containFiles_Name)
				{
					if(file.Contains(containStr))
						return false;
				}
			}

			if(ignoreFiles_Extension.Contains(extension))
				return true;

			foreach(string filterStr in ignoreFiles_Name)
			{
				if(file.Contains(filterStr))
					return true;
			}

			return false;
		}
		
		/// <summary>
		/// 忽略文件夹
		/// </summary>
		/// <returns><c>true</c> 被忽略返回; 否则返回, <c>false</c>.</returns>
		/// <param name="folder">待检测文件夹</param>
		bool IsIgnoreFolder(string folder)
		{
			if (!openFilter)
				return false;
			
			string extension = Path.GetExtension(folder);

			if(containFolders_Extension.Count > 0)
			{
				if(containFolders_Extension.Contains(extension))
					return false;
			}

			if(containFolders_Name.Count > 0)
			{
				foreach(string filterStr in containFolders_Name)
				{
					if(folder.Contains(filterStr))
						return false;
				}
			}

			if(ignoreFolders_Extension.Contains(extension))
				return true;

			foreach(string filterStr in ignoreFolders_Name)
			{
				if(folder.Contains(filterStr))
					return true;
			}

			return false;
		}
	}
}

调用方法：

using UnityEngine;
using System.IO;
using GEngine.Package;

public class NewBehaviourScript : MonoBehaviour 
{
	void Start () 
	{
		string dir = Directory.GetCurrentDirectory();
		string assetFolder = dir + @"\Assets";

		string configFile = dir + @"\Assets\Configs\zip.ini";

		GZip.Inst.OpenFilter(configFile);
		GZip.Inst.Compress( assetFolder, "ZipTest.zip");
		GZip.Inst.Decompress("ZipTest.zip", "DZ");
	}
}

配置(GEngine.ConfigSystem)

GEngine配置采用Nini库，基于C#库，支持中文编码，但不支持重复Key，自定义相关还没研究。基本上够用了，先暂时用这个库。配置系统待整合。

加密、解密(GEngine.Security.GDES)

GEngine加密解密算法采用DES算法，支持字符串、二进制、文件的加密、解密。

源码与实例：

GDES类：

using System.IO;
using System.Text;
using System.Security.Cryptography;

namespace GEngine.Security
{
	/// <summary>
	/// 加密解密
	/// </summary>
	public sealed class GDES
	{
		/// <summary>
		/// 密钥
		/// </summary>
		private static byte[] keys = Encoding.UTF8.GetBytes("83721590");

		/// <summary>
		/// 密钥向量
		/// </summary>
		private static byte[] ivs = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };

		/// <summary>
		/// 默认编码模式
		/// </summary>
		private static Encoding defualtEncoding = Encoding.UTF8;

		/// <summary>
		/// 加密
		/// </summary>
		/// <returns>返回加密后的byte[]数据</returns>
		/// <param name="bytes">需要加密的byte[]数据</param>
		public static byte[] EncryptToBytes(byte[] bytes)
		{
			if(bytes == null)
				return null;
			
			byte[] encrypted;
			ICryptoTransform encryptor = new DESCryptoServiceProvider().CreateEncryptor(keys, ivs);
			
			using (MemoryStream mStream = new MemoryStream())
			{
				using (CryptoStream cStream = new CryptoStream(mStream, encryptor, CryptoStreamMode.Write))
				{
					cStream.Write(bytes, 0, bytes.Length);
				}				
				encrypted = mStream.ToArray();
			}
			
			return encrypted;
		}

		/// <summary>
		/// 加密
		/// </summary>
		/// <returns>返回加密后的byte[]数据</returns>
		/// <param name="plainText">需要加密的string数据</param>
		/// <param name="encoding">编码模式</param>
		public static byte[] EncryptToBytes(string plainText, Encoding encoding = null)
		{
			if(string.IsNullOrEmpty(plainText))
				return null;

			if(encoding != null)
				return EncryptToBytes(encoding.GetBytes(plainText));
			
			byte[] encrypted;
			ICryptoTransform encryptor = new DESCryptoServiceProvider().CreateEncryptor(keys, ivs);

			using (MemoryStream mStream = new MemoryStream())
			{
				using (CryptoStream cStream = new CryptoStream(mStream, encryptor, CryptoStreamMode.Write))
				{
					using (StreamWriter sWriter = new StreamWriter(cStream))
					{
						sWriter.Write(plainText);
					}
					encrypted = mStream.ToArray();
				}
			}

			return encrypted;
		}

		/// <summary>
		/// 加密文件
		/// </summary>
		/// <param name="filePath">待加密的源文件</param>
		/// <param name="savePath">加密存储的目标文件</param>
		/// <param name="deleteOldFile">是否删除源文件</param>
		public static void EncryptToFile(string filePath, string savePath, bool deleteOldFile = false)
		{
			if(!File.Exists(filePath))
				return;

			byte[] bytes = File.ReadAllBytes(filePath);
			if(deleteOldFile)
				File.Delete(filePath);

			EncryptToFile(bytes, savePath);
		}

		/// <summary>
		/// 加密到文件
		/// </summary>
		/// <param name="bytes">待解密的byte[]数据</param>
		/// <param name="savePath">加密存储的目标文件</param>
		public static void EncryptToFile(byte[] bytes, string savePath)
		{
			if(bytes == null)
				return;

			string folder = Directory.GetParent(savePath).FullName;
			if(!Directory.Exists(folder))
			{
				Directory.CreateDirectory(folder);
			}

			byte[] encrypted = EncryptToBytes(bytes);
			File.WriteAllBytes(savePath, encrypted);
		}

		/// <summary>
		/// 解密
		/// </summary>
		/// <returns>返回解密后的byte[]数据</returns>
		/// <param name="bytes">待解密的byte[]数据</param>
		public static byte[] DecryptToBytes(byte[] bytes)
		{
			if(bytes == null)
				return null;
			
			byte[] decrypted = null;
			ICryptoTransform decryptor = new DESCryptoServiceProvider().CreateDecryptor(keys, ivs);
			
			using (MemoryStream mStream = new MemoryStream())
			{
				using (CryptoStream cStream = new CryptoStream(mStream, decryptor, CryptoStreamMode.Write))
				{
					cStream.Write(bytes, 0, bytes.Length);
				}				
				decrypted = mStream.ToArray();
			}				
			
			return decrypted;
		}

		/// <summary>
		/// 解密
		/// </summary>
		/// <returns>返回解密后的string数据</returns>
		/// <param name="bytes">待解密的byte[]数据</param>
		/// <param name="encoding">编码模式</param>
		public static string DecryptToString(byte[] bytes, Encoding encoding = null)
		{
			if(bytes == null)
				return null;

			byte[] decrypted = DecryptToBytes(bytes);
			if(decrypted == null)
				return null;

			if(encoding != null)
				return encoding.GetString(decrypted);
			else
				return defualtEncoding.GetString(decrypted);
		}

		/// <summary>
		/// 解密并存储到文件
		/// </summary>
		/// <param name="bytes">待解密的byte[]数据</param>
		/// <param name="savePath">解密后存储的目标文件</param>
		public static void DecryptToFile(byte[] bytes, string savePath)
		{
			if(bytes == null)
				return;

			byte[] decrypted = DecryptToBytes(bytes);

			string folder = Directory.GetParent(savePath).FullName;
			if(!Directory.Exists(folder))
			{
				Directory.CreateDirectory(folder);
			}
			File.WriteAllBytes(savePath, decrypted);
		}

		/// <summary>
		/// 解密并存储到文件
		/// </summary>
		/// <param name="filePath">待解密的源文件</param>
		/// <param name="savePath">解密后存储的目标文件</param>
		public static void DecryptToFile(string filePath, string savePath)
		{
			if(!File.Exists(filePath))
				return;
			
			byte[] bytes = File.ReadAllBytes(filePath);
			DecryptToFile(bytes, savePath);
		}
	}
}

调用方法：

using UnityEngine;
using System.IO;

using GEngine.Security;

public class NewBehaviourScript : MonoBehaviour 
{
	void Start () 
	{
		string dir = Directory.GetCurrentDirectory();
		string assetFolder = dir + @"\Assets";

		string configFile = dir + @"\Assets\Configs\zip.ini";

		string encPath = Path.ChangeExtension(configFile, "enc");
		GDES.EncryptToFile(configFile, encPath);
		string decPath = Path.ChangeExtension(configFile, "dec");
		GDES.DecryptToFile(encPath, decPath);
	}
}

相机角色中间物体透明(GEngine.BetweenTransparent)

两者中间对象透明组件，一般来说挂在主角上，监视者为主摄像机。剧情动画时可挂在动画主角上。该组件还支持反向检测、透明shader替换等（shader替换暂时做统一替换，如果需要，可以添加组件，然后让对象自定义替换shader）