Game/Fishing2Server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

提交导表相关功能

Browse Source
This commit is contained in:
Bob.Song
2025-09-27 17:53:39 +08:00
parent f899a55769
commit c1a3df2192
79 changed files with 4365 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

182
Tools/ConfigBuilder/NBConfigBuilder/Utils/FileHelper.cs Normal file
View File

@@ -0,0 +1,182 @@
using System.Text;
namespace NBConfigBuilder;
/// <summary>
/// 文件操作助手类，提供了各种文件操作方法。
/// </summary>
public static partial class FileHelper
{
/// <summary>
/// 获取相对路径的完整路径。
/// </summary>
/// <param name="relativePath">相对路径。</param>
/// <returns>完整路径。</returns>
public static string GetFullPath(string relativePath)
{
return Path.GetFullPath(Path.Combine(Directory.GetCurrentDirectory(), relativePath));
}
/// <summary>
/// 获取相对路径的完整路径。
/// </summary>
/// <param name="relativePath">相对于指定的目录的相对路径。</param>
/// <param name="srcDir">指定的目录</param>
/// <returns>完整路径。</returns>
public static string GetFullPath(string relativePath, string srcDir)
{
return Path.GetFullPath(Path.Combine(srcDir, relativePath));
}
/// <summary>
/// 获取相对路径的的文本信息。
/// </summary>
/// <param name="relativePath"></param>
/// <returns></returns>
public static async Task<string> GetTextByRelativePath(string relativePath)
{
var fullPath = GetFullPath(relativePath);
return await File.ReadAllTextAsync(fullPath, Encoding.UTF8);
}
/// <summary>
/// 获取绝对路径的的文本信息。
/// </summary>
/// <param name="fullPath"></param>
/// <returns></returns>
public static async Task<string> GetText(string fullPath)
{
return await File.ReadAllTextAsync(fullPath, Encoding.UTF8);
}
/// <summary>
/// 根据文件夹路径创建文件夹，如果文件夹不存在会自动创建文件夹。
/// </summary>
/// <param name="directoryPath"></param>
public static void CreateDirectory(string directoryPath)
{
if (directoryPath.LastIndexOf('/') != directoryPath.Length - 1)
{
directoryPath += "/";
}
var directoriesByFilePath = GetDirectoriesByFilePath(directoryPath);
foreach (var dir in directoriesByFilePath)
{
if (Directory.Exists(dir))
{
continue;
}
Directory.CreateDirectory(dir);
}
}
/// <summary>
/// 将文件复制到目标路径，如果目标目录不存在会自动创建目录。
/// </summary>
/// <param name="sourceFile">源文件路径。</param>
/// <param name="destinationFile">目标文件路径。</param>
/// <param name="overwrite">是否覆盖已存在的目标文件。</param>
public static void Copy(string sourceFile, string destinationFile, bool overwrite)
{
CreateDirectory(destinationFile);
File.Copy(sourceFile, destinationFile, overwrite);
}
/// <summary>
/// 获取文件路径内的所有文件夹路径。
/// </summary>
/// <param name="filePath">文件路径。</param>
/// <returns>文件夹路径列表。</returns>
public static IEnumerable<string> GetDirectoriesByFilePath(string filePath)
{
var dir = "";
var fileDirectories = filePath.Split('/');
for (var i = 0; i < fileDirectories.Length - 1; i++)
{
dir = $"{dir}{fileDirectories[i]}/";
yield return dir;
}
if (fileDirectories.Length == 1)
{
yield return filePath;
}
}
/// <summary>
/// 将文件夹内的所有内容复制到目标位置。
/// </summary>
/// <param name="sourceDirectory">源文件夹路径。</param>
/// <param name="destinationDirectory">目标文件夹路径。</param>
/// <param name="overwrite">是否覆盖已存在的文件。</param>
public static void CopyDirectory(string sourceDirectory, string destinationDirectory, bool overwrite)
{
// 创建目标文件夹
if (!Directory.Exists(destinationDirectory))
{
Directory.CreateDirectory(destinationDirectory);
}
// 获取当前文件夹中的所有文件
var files = Directory.GetFiles(sourceDirectory);
// 拷贝文件到目标文件夹
foreach (var file in files)
{
var fileName = Path.GetFileName(file);
var destinationPath = Path.Combine(destinationDirectory, fileName);
File.Copy(file, destinationPath, overwrite);
}
// 获取源文件夹中的所有子文件夹
var directories = Directory.GetDirectories(sourceDirectory);
// 递归方式拷贝文件夹
foreach (var directory in directories)
{
var directoryName = Path.GetFileName(directory);
var destinationPath = Path.Combine(destinationDirectory, directoryName);
CopyDirectory(directory, destinationPath, overwrite);
}
}
/// <summary>
/// 获取目录下的所有文件
/// </summary>
/// <param name="folderPath">文件夹路径。</param>
/// <param name="searchPattern">需要查找的文件通配符</param>
/// <param name="searchOption">查找的类型</param>
/// <returns></returns>
public static string[] GetDirectoryFile(string folderPath, string searchPattern, SearchOption searchOption)
{
return Directory.GetFiles(folderPath, searchPattern, searchOption);
}
/// <summary>
/// 清空文件夹内的所有文件。
/// </summary>
/// <param name="folderPath">文件夹路径。</param>
public static void ClearDirectoryFile(string folderPath)
{
if (!Directory.Exists(folderPath))
{
return;
}
var files = Directory.GetFiles(folderPath);
foreach (var file in files)
{
File.Delete(file);
}
}
}

228
Tools/ConfigBuilder/NBConfigBuilder/Utils/HashCodeHelper.cs Normal file
View File

@@ -0,0 +1,228 @@
using System.Security.Cryptography;
using System.Text;
namespace NBConfigBuilder;
/// <summary>
/// HashCode算法帮助类
/// </summary>
public static partial class HashCodeHelper
{
private static readonly SHA256 Sha256Hash = SHA256.Create();
/// <summary>
/// 计算两个字符串的HashCode
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
public static int GetHashCode(string a, string b)
{
var hash = 17;
hash = hash * 31 + a.GetHashCode();
hash = hash * 31 + b.GetHashCode();
return hash;
}
#if FANTASY_NET || !FANTASY_WEBGL
/// <summary>
/// 使用bkdr算法生成一个long的值
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
public static unsafe long GetBKDRHashCode(string str)
{
ulong hash = 0;
// 如果要修改这个种子、建议选择一个质数来做种子
const uint seed = 13131; // 31 131 1313 13131 131313 etc..
fixed (char* p = str)
{
for (var i = 0; i < str.Length; i++)
{
var c = p[i];
var high = (byte)(c >> 8);
var low = (byte)(c & byte.MaxValue);
hash = hash * seed + high;
hash = hash * seed + low;
}
}
return (long)hash;
}
/// <summary>
/// 使用MurmurHash3算法生成一个uint的值
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
public static unsafe uint MurmurHash3(string str)
{
const uint seed = 0xc58f1a7b;
uint hash = seed;
uint c1 = 0xcc9e2d51;
uint c2 = 0x1b873593;
fixed (char* p = str)
{
var current = p;
for (var i = 0; i < str.Length; i++)
{
var k1 = (uint)(*current);
k1 *= c1;
k1 = (k1 << 15) | (k1 >> (32 - 15));
k1 *= c2;
hash ^= k1;
hash = (hash << 13) | (hash >> (32 - 13));
hash = hash * 5 + 0xe6546b64;
current++;
}
}
hash ^= (uint)str.Length;
hash ^= hash >> 16;
hash *= 0x85ebca6b;
hash ^= hash >> 13;
hash *= 0xc2b2ae35;
hash ^= hash >> 16;
return hash;
}
/// <summary>
/// 使用MurmurHash3算法生成一个long的值
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
public static unsafe long ComputeHash64(string str)
{
const ulong seed = 0xc58f1a7bc58f1a7bUL; // 64-bit seed
var hash = seed;
var c1 = 0x87c37b91114253d5UL;
var c2 = 0x4cf5ad432745937fUL;
fixed (char* p = str)
{
var current = p;
for (var i = 0; i < str.Length; i++)
{
var k1 = (ulong)(*current);
k1 *= c1;
k1 = (k1 << 31) | (k1 >> (64 - 31));
k1 *= c2;
hash ^= k1;
hash = (hash << 27) | (hash >> (64 - 27));
hash = hash * 5 + 0x52dce729;
current++;
}
}
hash ^= (ulong)str.Length;
hash ^= hash >> 33;
hash *= 0xff51afd7ed558ccdUL;
hash ^= hash >> 33;
hash *= 0xc4ceb9fe1a85ec53UL;
hash ^= hash >> 33;
return (long)hash;
}
#endif
#if FANTASY_WEBGL
/// <summary>
/// 使用bkdr算法生成一个long的值
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
public static long GetBKDRHashCode(string str)
{
long hash = 0;
// 如果要修改这个种子、建议选择一个质数来做种子
const uint seed = 13131; // 31 131 1313 13131 131313 etc..
foreach (var c in str)
{
var high = (byte)(c >> 8);
var low = (byte)(c & byte.MaxValue);
hash = hash * seed + high;
hash = hash * seed + low;
}
return hash;
}
/// <summary>
/// 使用MurmurHash3算法生成一个uint的值
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
public static uint MurmurHash3(string str)
{
const uint seed = 0xc58f1a7b;
uint hash = seed;
uint c1 = 0xcc9e2d51;
uint c2 = 0x1b873593;
foreach (var t in str)
{
var k1 = (uint)(t);
k1 *= c1;
k1 = (k1 << 15) | (k1 >> (32 - 15));
k1 *= c2;
hash ^= k1;
hash = (hash << 13) | (hash >> (32 - 13));
hash = hash * 5 + 0xe6546b64;
}
hash ^= (uint)str.Length;
hash ^= hash >> 16;
hash *= 0x85ebca6b;
hash ^= hash >> 13;
hash *= 0xc2b2ae35;
hash ^= hash >> 16;
return hash;
}
/// <summary>
/// 使用MurmurHash3算法生成一个long的值
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
public static long ComputeHash64(string str)
{
const ulong seed = 0xc58f1a7bc58f1a7bUL; // 64-bit seed
var hash = seed;
var c1 = 0x87c37b91114253d5UL;
var c2 = 0x4cf5ad432745937fUL;
foreach (var t in str)
{
var k1 = (ulong)(t);
k1 *= c1;
k1 = (k1 << 31) | (k1 >> (64 - 31));
k1 *= c2;
hash ^= k1;
hash = (hash << 27) | (hash >> (64 - 27));
hash = hash * 5 + 0x52dce729;
}
hash ^= (ulong)str.Length;
hash ^= hash >> 33;
hash *= 0xff51afd7ed558ccdUL;
hash ^= hash >> 33;
hash *= 0xc4ceb9fe1a85ec53UL;
hash ^= hash >> 33;
return (long)hash;
}
#endif
/// <summary>
/// 根据字符串计算一个Hash值
/// </summary>
/// <param name="rawData"></param>
/// <returns></returns>
public static int ComputeSha256HashAsInt(string rawData)
{
var bytes = Sha256Hash.ComputeHash(Encoding.UTF8.GetBytes(rawData));
return (bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3];
}
}

65
Tools/ConfigBuilder/NBConfigBuilder/Utils/TimeHelper.cs Normal file
View File

@@ -0,0 +1,65 @@
namespace NBConfigBuilder;
/// <summary>
/// 提供与时间相关的帮助方法。
/// </summary>
public static partial class TimeHelper
{
/// <summary>
/// 一小时的毫秒值。
/// </summary>
public const long Hour = 3600000;
/// <summary>
/// 一分钟的毫秒值。
/// </summary>
public const long Minute = 60000;
/// <summary>
/// 一天的毫秒值。
/// </summary>
public const long OneDay = 86400000;
// 1970年1月1日的Ticks
private const long Epoch = 621355968000000000L;
/// <summary>
/// 获取当前时间的毫秒数，从1970年1月1日开始计算。
/// </summary>
public static long Now => (DateTime.UtcNow.Ticks - Epoch) / 10000;
/// <summary>
/// 根据时间获取时间戳
/// </summary>
public static long Transition(DateTime dateTime)
{
return (dateTime.ToUniversalTime().Ticks - Epoch) / 10000;
}
/// <summary>
/// 根据时间获取 时间戳
/// </summary>
public static long TransitionToSeconds(DateTime dateTime)
{
return (dateTime.ToUniversalTime().Ticks - Epoch) / 10000000;
}
/// <summary>
/// 将毫秒数转换为日期时间。
/// </summary>
/// <param name="timeStamp">要转换的毫秒数。</param>
/// <returns>转换后的日期时间。</returns>
public static DateTime Transition(this long timeStamp)
{
return new DateTime(Epoch + timeStamp * 10000, DateTimeKind.Utc).ToUniversalTime();
}
/// <summary>
/// 将毫秒数转换为本地时间的日期时间。
/// </summary>
/// <param name="timeStamp">要转换的毫秒数。</param>
/// <returns>转换后的本地时间的日期时间。</returns>
public static DateTime TransitionLocal(this long timeStamp)
{
return new DateTime(Epoch + timeStamp * 10000, DateTimeKind.Utc).ToLocalTime();
}
}