Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
 KujiKita
|
792781a5f7 | ||
|
KujiKita
|
773e148783 | ||
|
KujiKita
|
87d4862af5 | ||
|
Kuji Kitamura
|
b26cdc8b5c | ||
|
KujiKita
|
6e2f5746b0 | ||
|
KujiKita
|
3f883c4c77 | ||
|
KujiKita
|
0863721dc4 | ||
|
KujiKita
|
e0d651bd55 | ||
|
KujiKita
|
3bbbea9536 | ||
|
KujiKita
|
4de7bd32f7 | ||
|
KujiKita
|
93f905d3e1 | ||
|
KujiKita
|
4c8b293beb | ||
|
korenkonder
|
72141ef603 |
@@ -1,5 +1,7 @@
|
||||
.vs
|
||||
build
|
||||
KKdBaseLib/bin
|
||||
KKdBaseLib/obj
|
||||
KKdMainLib/bin
|
||||
KKdMainLib/obj
|
||||
KKdMathLib/bin
|
||||
|
||||
@@ -1,10 +1,8 @@
|
||||
//Original research by Samyuu
|
||||
|
||||
using KKdMainLib.IO;
|
||||
|
||||
namespace KKdMainLib
|
||||
namespace KKdBaseLib
|
||||
{
|
||||
public static class DCC //Databank_Checksum_Calculator
|
||||
public static class DCC //Databank Checksum Calculator
|
||||
{
|
||||
private static readonly ushort[] ChecksumLookupTable = {
|
||||
0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
|
||||
@@ -41,14 +39,11 @@ namespace KKdMainLib
|
||||
0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0,
|
||||
};
|
||||
|
||||
public static ushort CalculateChecksum(string file) => CalculateChecksum(File.ReadAllBytes(file));
|
||||
|
||||
public static ushort CalculateChecksum(byte[] data)
|
||||
{
|
||||
ushort result = 0xFFFF;
|
||||
for (int i = 0; i < data.Length; i++)
|
||||
result = (ushort)(ChecksumLookupTable[(result >> 8) ^ data[i]] ^ (result << 8));
|
||||
|
||||
return result;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,267 @@
|
||||
using System;
|
||||
|
||||
namespace KKdBaseLib
|
||||
{
|
||||
public static unsafe class Extensions
|
||||
{
|
||||
private const double RadPi = 180 / Math.PI;
|
||||
public static double ToDegrees(this double val) => val * RadPi;
|
||||
public static double ToRadians(this double val) => val / RadPi;
|
||||
|
||||
public static double Acos (this double d ) => Math.Acos (d );
|
||||
public static double Asin (this double d ) => Math.Asin (d );
|
||||
public static double Atan (this double d ) => Math.Atan (d );
|
||||
public static double Aсtg (this double d ) => 1 / Math.Atan (d );
|
||||
public static double Cos (this double d ) => Math.Cos (d );
|
||||
public static double Cosh (this double val) => Math.Cosh (val);
|
||||
public static double Sin (this double a ) => Math.Sin (a );
|
||||
public static double Sinh (this double val) => Math.Sinh (val);
|
||||
public static double Tan (this double a ) => Math.Tan (a );
|
||||
public static double Tanh (this double val) => Math.Tanh (val);
|
||||
public static double Ctg (this double a ) => 1 / Math.Tan (a );
|
||||
public static double Ctgh (this double val) => 1 / Math.Tanh (val);
|
||||
|
||||
public static double Abs (this double val) => Math.Abs (val);
|
||||
public static double Ceiling(this double a ) => Math.Ceiling(a );
|
||||
public static double Exp (this double d ) => Math.Exp (d );
|
||||
public static double Log (this double d ) => Math.Log (d );
|
||||
public static double Log10 (this double d ) => Math.Log10 (d );
|
||||
public static double Round (this double d ) => Math.Round (d );
|
||||
public static int Sign (this double val) => Math.Sign (val);
|
||||
public static double Sqrt (this double d ) => Math.Sqrt (d );
|
||||
|
||||
|
||||
public static double Atan2(this double y , double x ) => Math.Atan2(y , x );
|
||||
public static double Log (this double val , double newBase) => Math.Log (val , newBase);
|
||||
public static double Max (this double val1, double val2 ) => Math.Max (val1, val2 );
|
||||
public static double Min (this double val1, double val2 ) => Math.Min (val1, val2 );
|
||||
public static double Pow (this double x , double y ) => Math.Pow (x , y );
|
||||
public static double Round(this double val , int d ) => Math.Round(val , d );
|
||||
|
||||
public static float ToDegrees(this float val) => (float)(val * RadPi);
|
||||
public static float ToRadians(this float val) => (float)(val / RadPi);
|
||||
|
||||
public static float Acos (this float d ) => (float) Math.Acos (d ) ;
|
||||
public static float Asin (this float d ) => (float) Math.Asin (d ) ;
|
||||
public static float Atan (this float d ) => (float) Math.Atan (d ) ;
|
||||
public static float Aсtg (this float d ) => (float)(1 / Math.Atan (d ));
|
||||
public static float Cos (this float d ) => (float) Math.Cos (d ) ;
|
||||
public static float Cosh (this float val) => (float) Math.Cosh (val) ;
|
||||
public static float Sin (this float a ) => (float) Math.Sin (a ) ;
|
||||
public static float Sinh (this float val) => (float) Math.Sinh (val) ;
|
||||
public static float Tan (this float a ) => (float) Math.Tan (a ) ;
|
||||
public static float Tanh (this float val) => (float) Math.Tanh (val) ;
|
||||
public static float Ctg (this float a ) => (float)(1 / Math.Tan (a ));
|
||||
public static float Ctgh (this float val) => (float)(1 / Math.Tanh (val));
|
||||
|
||||
public static float Abs (this float val) => Math.Abs (val) ;
|
||||
public static float Ceiling(this float a ) => (float) Math.Ceiling(a ) ;
|
||||
public static float Exp (this float d ) => (float) Math.Exp (d ) ;
|
||||
public static float Log (this float d ) => (float) Math.Log (d ) ;
|
||||
public static float Log10 (this float d ) => (float) Math.Log10 (d ) ;
|
||||
public static float Round (this float d ) => (float) Math.Round (d ) ;
|
||||
public static float Sqrt (this float d ) => (float) Math.Sqrt (d ) ;
|
||||
|
||||
|
||||
public static float Atan2(this float y , float x ) => (float)Math.Atan2(y , x );
|
||||
public static float Log (this float val , float newBase) => (float)Math.Log (val , newBase);
|
||||
public static float Max (this float val1, float val2 ) => Math.Max (val1, val2 );
|
||||
public static float Min (this float val1, float val2 ) => Math.Min (val1, val2 );
|
||||
public static float Pow (this float x , float y ) => (float)Math.Pow (x , y );
|
||||
public static float Round(this float val , int d ) => (float)Math.Round(val , d );
|
||||
|
||||
public static void FloorCeiling( ref double Value) =>
|
||||
Value = Value % 1 >= 0.5 ? (long)(Value + 0.5) : (long) Value;
|
||||
|
||||
public static long FloorCeiling(this double Value) =>
|
||||
Value % 1 >= 0.5 ? (long)(Value + 0.5) : (long) Value;
|
||||
|
||||
public static int Align(this int value, int alignement, int divide = 1) =>
|
||||
((value % alignement == 0) ? value : (value + alignement - value % alignement)) / divide;
|
||||
|
||||
public static uint Align(this uint value, uint alignement, uint divide = 1) =>
|
||||
((value % alignement == 0) ? value : (value + alignement - value % alignement)) / divide;
|
||||
|
||||
public static long Align(this long value, long alignement, long divide = 1) =>
|
||||
((value % alignement == 0) ? value : (value + alignement - value % alignement)) / divide;
|
||||
|
||||
public static ulong Align(this ulong value, ulong alignement, ulong divide = 1) =>
|
||||
((value % alignement == 0) ? value : (value + alignement - value % alignement)) / divide;
|
||||
|
||||
public static byte[] buf = new byte[8];
|
||||
public static byte* bufPtr = buf.GetPtr();
|
||||
|
||||
public static byte[] Endian(this byte[] LE, byte Len)
|
||||
{ for (byte i = 0; i < Len; i++) bufPtr[i] = LE[i];
|
||||
for (byte i = 0; i < Len; i++) LE[Len - i - 1] = bufPtr[i]; return LE; }
|
||||
|
||||
public static byte[] Endian(this byte[] LE, byte Len, bool IsBE)
|
||||
{ if (IsBE) { for (byte i = 0; i < Len; i++) bufPtr[i] = LE[i];
|
||||
for (byte i = 0; i < Len; i++) LE[Len - i - 1] = bufPtr[i]; } return LE; }
|
||||
|
||||
public static short Endian(this short LE, bool IsBE)
|
||||
{ if (IsBE) { int TLE = 0; for (byte i = 0; i < 2; i++) { bufPtr[i] = (byte)LE; LE >>= 8; } LE = 0;
|
||||
for (byte i = 0; i < 2; i++) { TLE |= bufPtr[i]; if (i < 1) TLE <<= 8; } LE = (short)TLE; } return LE; }
|
||||
|
||||
public static ushort Endian(this ushort LE, bool IsBE)
|
||||
{ if (IsBE) { for (byte i = 0; i < 2; i++) { bufPtr[i] = (byte)LE; LE >>= 8; } LE = 0;
|
||||
for (byte i = 0; i < 2; i++) { LE |= bufPtr[i]; if (i < 1) LE <<= 8; } } return LE; }
|
||||
|
||||
public static int Endian(this int LE, bool IsBE)
|
||||
{ if (IsBE) { for (byte i = 0; i < 4; i++) { bufPtr[i] = (byte)LE; LE >>= 8; } LE = 0;
|
||||
for (byte i = 0; i < 4; i++) { LE |= bufPtr[i]; if (i < 3) LE <<= 8; } } return LE; }
|
||||
|
||||
public static uint Endian(this uint LE, bool IsBE)
|
||||
{ if (IsBE) { for (byte i = 0; i < 4; i++) { bufPtr[i] = (byte)LE; LE >>= 8; } LE = 0;
|
||||
for (byte i = 0; i < 4; i++) { LE |= bufPtr[i]; if (i < 3) LE <<= 8; } } return LE; }
|
||||
|
||||
public static long Endian(this long LE, bool IsBE)
|
||||
{ if (IsBE) { for (byte i = 0; i < 8; i++) { bufPtr[i] = (byte)LE; LE >>= 8; } LE = 0;
|
||||
for (byte i = 0; i < 8; i++) { LE |= bufPtr[i]; if (i < 7) LE <<= 8; } } return LE; }
|
||||
|
||||
public static ulong Endian(this ulong LE, bool IsBE)
|
||||
{ if (IsBE) { for (byte i = 0; i < 8; i++) { bufPtr[i] = (byte)LE; LE >>= 8; } LE = 0;
|
||||
for (byte i = 0; i < 8; i++) { LE |= bufPtr[i]; if (i < 7) LE <<= 8; } } return LE; }
|
||||
|
||||
public static sbyte CITSB(this int c)
|
||||
{ if (c > 0x0000007F) c = 0x0000007F;
|
||||
else if (c < -0x00000080) c = -0x00000080; return ( sbyte)c; }
|
||||
|
||||
public static byte CITB (this int c)
|
||||
{ if (c > 0x000000FF) c = 0x000000FF;
|
||||
else if (c < 0x00000000) c = 0x00000000; return ( byte)c; }
|
||||
|
||||
public static short CITS (this int c)
|
||||
{ if (c > 0x00007FFF) c = 0x00007FFF;
|
||||
else if (c < -0x00008000) c = -0x00008000; return ( short)c; }
|
||||
|
||||
public static ushort CITUS(this int c)
|
||||
{ if (c > 0x0000FFFF) c = 0x0000FFFF;
|
||||
else if (c < 0x00000000) c = 0x00000000; return (ushort)c; }
|
||||
|
||||
public static sbyte CFTSB(this float c)
|
||||
{ c = c.Round(); if (c > 0x0000007F) c = 0x0000007F;
|
||||
else if (c < -0x00000080) c = -0x00000080; return ( sbyte)c; }
|
||||
|
||||
public static byte CFTB (this float c)
|
||||
{ c = c.Round(); if (c > 0x000000FF) c = 0x000000FF;
|
||||
else if (c < 0x00000000) c = 0x00000000; return ( byte)c; }
|
||||
|
||||
public static short CFTS (this float c)
|
||||
{ c = c.Round(); if (c > 0x00007FFF) c = 0x00007FFF;
|
||||
else if (c < -0x00008000) c = -0x00008000; return ( short)c; }
|
||||
|
||||
public static ushort CFTUS(this float c)
|
||||
{ c = c.Round(); if (c > 0x0000FFFF) c = 0x0000FFFF;
|
||||
else if (c < 0x00000000) c = 0x00000000; return (ushort)c; }
|
||||
|
||||
public static int CFTI (this float c)
|
||||
{ c = c.Round(); return ( int)c; }
|
||||
|
||||
public static uint CFTUI(this float c)
|
||||
{ c = c.Round(); return ( uint)c; }
|
||||
|
||||
public static sbyte CFTSB(this double c)
|
||||
{ c = c.Round(); if (c > 0x0000007F) c = 0x0000007F;
|
||||
else if (c < -0x00000080) c = -0x00000080; return ( sbyte)c; }
|
||||
|
||||
public static byte CFTB (this double c)
|
||||
{ c = c.Round(); if (c > 0x000000FF) c = 0x000000FF;
|
||||
else if (c < 0x00000000) c = 0x00000000; return ( byte)c; }
|
||||
|
||||
public static short CFTS (this double c)
|
||||
{ c = c.Round(); if (c > 0x00007FFF) c = 0x00007FFF;
|
||||
else if (c < -0x00008000) c = -0x00008000; return ( short)c; }
|
||||
|
||||
public static ushort CFTUS(this double c)
|
||||
{ c = c.Round(); if (c > 0x0000FFFF) c = 0x0000FFFF;
|
||||
else if (c < 0x00000000) c = 0x00000000; return (ushort)c; }
|
||||
|
||||
public static int CFTI (this double c)
|
||||
{ c = c.Round(); if (c > 0x7FFFFFFF) c = 0x7FFFFFFF;
|
||||
else if (c < -0x80000000) c = -0x80000000; return ( int)c; }
|
||||
|
||||
public static uint CFTUI(this double c)
|
||||
{ c = c.Round(); if (c > 0xFFFFFFFF) c = 0xFFFFFFFF;
|
||||
else if (c < 0x00000000) c = 0x00000000; return ( uint)c; }
|
||||
|
||||
public static int ToInt32(this float f) => *( int*)&f;
|
||||
public static uint ToUInt32(this float f) => *( uint*)&f;
|
||||
public static long ToInt64(this double f) => *( long*)&f;
|
||||
public static ulong ToUInt64(this double f) => *(ulong*)&f;
|
||||
|
||||
public static float ToSingle(this int i) => *( float*)&i;
|
||||
public static float ToSingle(this uint i) => *( float*)&i;
|
||||
public static double ToDouble(this long i) => *(double*)&i;
|
||||
public static double ToDouble(this ulong i) => *(double*)&i;
|
||||
|
||||
public static sbyte* GetPtr(this sbyte[] array) { fixed ( sbyte* tempPtr = array) return tempPtr; }
|
||||
public static byte* GetPtr(this byte[] array) { fixed ( byte* tempPtr = array) return tempPtr; }
|
||||
public static short* GetPtr(this short[] array) { fixed ( short* tempPtr = array) return tempPtr; }
|
||||
public static ushort* GetPtr(this ushort[] array) { fixed (ushort* tempPtr = array) return tempPtr; }
|
||||
public static int* GetPtr(this int[] array) { fixed ( int* tempPtr = array) return tempPtr; }
|
||||
public static uint* GetPtr(this uint[] array) { fixed ( uint* tempPtr = array) return tempPtr; }
|
||||
public static long* GetPtr(this long[] array) { fixed ( long* tempPtr = array) return tempPtr; }
|
||||
public static ulong* GetPtr(this ulong[] array) { fixed ( ulong* tempPtr = array) return tempPtr; }
|
||||
public static float* GetPtr(this float[] array) { fixed ( float* tempPtr = array) return tempPtr; }
|
||||
public static double* GetPtr(this double[] array) { fixed (double* tempPtr = array) return tempPtr; }
|
||||
|
||||
public static string ToString(this int d, bool IsBE) =>
|
||||
BitConverter.GetBytes(d.Endian(IsBE)).ToASCII();
|
||||
|
||||
public static string ToString(this object d)
|
||||
{
|
||||
if (d == null) return "Null";
|
||||
else if (d is bool Boolean) return Boolean ? "true" : "false";
|
||||
else if (d is float F32 ) return ToString(F32);
|
||||
else if (d is double F64 ) return ToString(F64);
|
||||
return d.ToString();
|
||||
}
|
||||
|
||||
private static readonly string NumberDecimalSeparator =
|
||||
System.Globalization.NumberFormatInfo.CurrentInfo.NumberDecimalSeparator;
|
||||
|
||||
public static string ToString(this bool? d) => d.GetValueOrDefault().ToString();
|
||||
public static string ToString(this bool d) => d.ToString().ToLower();
|
||||
public static string ToString(this sbyte? d) => d.GetValueOrDefault().ToString();
|
||||
public static string ToString(this sbyte d) => d.ToString();
|
||||
public static string ToString(this byte? d) => d.GetValueOrDefault().ToString();
|
||||
public static string ToString(this byte d) => d.ToString();
|
||||
public static string ToString(this short? d) => d.GetValueOrDefault().ToString();
|
||||
public static string ToString(this short d) => d.ToString();
|
||||
public static string ToString(this ushort? d) => d.GetValueOrDefault().ToString();
|
||||
public static string ToString(this ushort d) => d.ToString();
|
||||
public static string ToString(this int? d) => d.GetValueOrDefault().ToString();
|
||||
public static string ToString(this int d) => d.ToString();
|
||||
public static string ToString(this uint? d) => d.GetValueOrDefault().ToString();
|
||||
public static string ToString(this uint d) => d.ToString();
|
||||
public static string ToString(this long? d) => d.GetValueOrDefault().ToString();
|
||||
public static string ToString(this long d) => d.ToString();
|
||||
public static string ToString(this ulong? d) => d.GetValueOrDefault().ToString();
|
||||
public static string ToString(this ulong d) => d.ToString();
|
||||
public static string ToString(this float? d, byte round) => d.GetValueOrDefault().ToString(round);
|
||||
public static string ToString(this float? d) => d.GetValueOrDefault().ToString();
|
||||
public static string ToString(this float d, byte round) =>
|
||||
Math.Round(d, round).ToString().ToLower().Replace(NumberDecimalSeparator, ".");
|
||||
public static string ToString(this float d) =>
|
||||
d .ToString().ToLower().Replace(NumberDecimalSeparator, ".");
|
||||
public static string ToString(this double? d, byte round) => d.GetValueOrDefault().ToString(round);
|
||||
public static string ToString(this double? d) => d.GetValueOrDefault().ToString();
|
||||
public static string ToString(this double d, byte round) =>
|
||||
Math.Round(d, round).ToString().ToLower().Replace(NumberDecimalSeparator, ".");
|
||||
public static string ToString(this double d) =>
|
||||
d .ToString().ToLower().Replace(NumberDecimalSeparator, ".");
|
||||
public static float ToSingle(this string s) =>
|
||||
float. Parse(s.Replace(".", NumberDecimalSeparator));
|
||||
public static bool ToSingle(this string s, out float value) =>
|
||||
float.TryParse(s.Replace(".", NumberDecimalSeparator), out value);
|
||||
public static double ToDouble(this string s) =>
|
||||
double. Parse(s.Replace(".", NumberDecimalSeparator));
|
||||
public static bool ToDouble(this string s, out double value) =>
|
||||
double.TryParse(s.Replace(".", NumberDecimalSeparator), out value);
|
||||
public static bool ToSingle(this string s, out float? value)
|
||||
{ bool Val = ToSingle(s, out float val); value = val; return Val; }
|
||||
public static bool ToDouble(this string s, out double? value)
|
||||
{ bool Val = ToDouble(s, out double val); value = val; return Val; }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,222 @@
|
||||
namespace KKdBaseLib.F2
|
||||
{
|
||||
public unsafe struct ENRSList
|
||||
{
|
||||
public int ID;
|
||||
public bool EOFC;
|
||||
public KKdList<ENRS> List;
|
||||
|
||||
public bool IsNull => List. IsNull;
|
||||
public bool NotNull => List.NotNull;
|
||||
|
||||
public static ENRSList Read(byte[] data, int ID = 0, bool EOFC = false)
|
||||
{
|
||||
byte* ptr = data.GetPtr();
|
||||
int i, i0;
|
||||
int ENRSCount = ((int*)ptr)[1];
|
||||
KKdList<ENRS> List = KKdList<ENRS>.New;
|
||||
ptr += 0x10;
|
||||
|
||||
for (i = 0; i < ENRSCount; i++)
|
||||
{
|
||||
ENRS ENR;
|
||||
ENR.Offset = ReadENRSValue(ref ptr);
|
||||
ENR.Count = ReadENRSValue(ref ptr);
|
||||
ENR.Size = ReadENRSValue(ref ptr);
|
||||
ENR.Repeat = ReadENRSValue(ref ptr);
|
||||
|
||||
if (i > 0) ENR.Offset += List[List.Count - 1].Offset;
|
||||
|
||||
if (ENR.Repeat < 1) { ENR.Sub = null; List.Add(ENR); continue; }
|
||||
|
||||
ENR.Sub = new KKdList<ENRS.SubENRS> { Capacity = ENR.Count };
|
||||
for (i0 = 0; i0 < ENR.Count; i0++)
|
||||
{
|
||||
ENRS.SubENRS Sub = ENR.Sub[0];
|
||||
Sub.Skip = ReadENRSValue(ref ptr, out Sub.Type) + i0 > 0 ? ENR.Sub[i0 - 1].SizeSkip : 0;
|
||||
Sub.Reverse = ReadENRSValue(ref ptr);
|
||||
ENR.Sub.Add(Sub);
|
||||
|
||||
if (ENR.Sub[i0].Type == ENRS.Type.Invalid) return default;
|
||||
}
|
||||
List.Add(ENR);
|
||||
}
|
||||
return new ENRSList { EOFC = EOFC, ID = ID, List = List };
|
||||
}
|
||||
|
||||
public static byte[] Write(ENRSList ENRS)
|
||||
{
|
||||
int i, i0;
|
||||
byte[] data;
|
||||
byte* ptr;
|
||||
|
||||
KKdList<ENRS> List = (System.Collections.Generic.List<ENRS>)ENRS.List;
|
||||
if (ENRS.IsNull || ENRS.List.Count < 1) return new byte[0x20];
|
||||
|
||||
int length = 0x10;
|
||||
for (i = 0; i < ENRS.List.Count; i++)
|
||||
{
|
||||
length += 0x10;
|
||||
ENRS ENR = ENRS.List[i];
|
||||
if (ENR.Repeat > 0 && ENR.Sub.NotNull)
|
||||
{
|
||||
ENR.Count = ENR.Sub.Count;
|
||||
length += 0x8 * ENR.Count;
|
||||
}
|
||||
else ENR.Repeat = 0;
|
||||
ENRS.List[i] = ENR;
|
||||
}
|
||||
data = new byte[length];
|
||||
ptr = data.GetPtr();
|
||||
((int*)ptr)[1] = ENRS.List.Count;
|
||||
ptr += 0x10;
|
||||
|
||||
for (i = 0; i < ENRS.List.Count; i++)
|
||||
{
|
||||
ENRS ENR = ENRS.List[i];
|
||||
WriteENRSValue(ref ptr, i > 0 ? ENR.Offset - ENRS.List[i - 1].Offset : ENR.Offset);
|
||||
WriteENRSValue(ref ptr, ENR.Count );
|
||||
WriteENRSValue(ref ptr, ENR.Size );
|
||||
WriteENRSValue(ref ptr, ENR.Repeat);
|
||||
|
||||
if (ENR.Repeat < 1) continue;
|
||||
|
||||
for (i0 = 0; i0 < ENR.Count; i0++)
|
||||
{
|
||||
if (ENR.Sub[i0].Type < ENRSList.ENRS.Type. WORD ||
|
||||
ENR.Sub[i0].Type > ENRSList.ENRS.Type.QWORD)
|
||||
return GetFinalArray(data, ptr);
|
||||
|
||||
WriteENRSValue(ref ptr, i0 > 0 ? ENR.Sub[i0].Skip - ENR.Sub[i0 - 1].SizeSkip : ENR.Sub[i0].Skip, ENR.Sub[i0].Type);
|
||||
WriteENRSValue(ref ptr, ENR.Sub[i0].Reverse);
|
||||
}
|
||||
|
||||
}
|
||||
return GetFinalArray(data, ptr);
|
||||
}
|
||||
|
||||
[System.ThreadStatic] private static ENRS.Value Value;
|
||||
|
||||
private static byte[] GetFinalArray(byte[] data, byte* ptr)
|
||||
{
|
||||
byte* Ptr = data.GetPtr();
|
||||
long length = (long)ptr - (long)Ptr;
|
||||
byte[] tempdata = new byte[length.Align(0x10)];
|
||||
for (int i = 0; i < length; i++) tempdata[i] = data[i];
|
||||
data = null;
|
||||
return tempdata;
|
||||
}
|
||||
|
||||
private static int ReadENRSValue(ref byte* ptr, out ENRS.Type Type)
|
||||
{
|
||||
int V = *ptr & 0xF;
|
||||
Type = (ENRS. Type)((*ptr & 0x30) >> 4);
|
||||
Value = (ENRS.Value)((*ptr & 0xC0) >> 6);
|
||||
ptr++;
|
||||
if (Value == ENRS.Value.Int32 )
|
||||
{ V = (V << 24) | (ptr[0] << 16) | (ptr[1] << 8) | ptr[2]; ptr += 3; }
|
||||
else if (Value == ENRS.Value.Int16 )
|
||||
{ V = (V << 8) | ptr[0]; ptr += 1; }
|
||||
else if (Value == ENRS.Value.Invalid) V = 0;
|
||||
return V;
|
||||
}
|
||||
|
||||
private static int ReadENRSValue(ref byte* ptr)
|
||||
{
|
||||
int V = *ptr & 0x3F;
|
||||
Value = (ENRS.Value)((*ptr & 0xC0) >> 6);
|
||||
ptr++;
|
||||
if (Value == ENRS.Value.Int32 )
|
||||
{ V = (V << 24) | (ptr[0] << 16) | (ptr[1] << 8) | ptr[2]; ptr += 3; }
|
||||
else if (Value == ENRS.Value.Int16 )
|
||||
{ V = (V << 8) | ptr[0]; ptr += 1; }
|
||||
else if (Value == ENRS.Value.Invalid) V = 0;
|
||||
return V;
|
||||
}
|
||||
|
||||
private static void WriteENRSValue(ref byte* ptr, int Val, ENRS.Type Type)
|
||||
{
|
||||
Value = ENRS.Value.Invalid;
|
||||
if (Val < 0x00000040) Value = ENRS.Value.Int8 ;
|
||||
else if (Val < 0x00004000) Value = ENRS.Value.Int16;
|
||||
else if (Val < 0x40000000) Value = ENRS.Value.Int32;
|
||||
*ptr = (byte)((((byte)Value << 6) & 0xC0) | (((byte)Type << 4) & 0x30));
|
||||
|
||||
if (Val < 0x00000010)
|
||||
{ *ptr |= (byte)( Val & 0x0F); }
|
||||
else if (Val < 0x00001000)
|
||||
{ *ptr |= (byte)((Val >> 8) & 0x0F); ptr++;
|
||||
*ptr = (byte)( Val & 0xFF); }
|
||||
else if (Val < 0x10000000)
|
||||
{ *ptr |= (byte)((Val >> 24) & 0x0F); ptr++;
|
||||
*ptr = (byte)((Val >> 16) & 0xFF); ptr++;
|
||||
*ptr = (byte)((Val >> 8) & 0xFF); ptr++;
|
||||
*ptr = (byte)( Val & 0xFF); }
|
||||
ptr++;
|
||||
}
|
||||
|
||||
private static void WriteENRSValue(ref byte* ptr, int Val)
|
||||
{
|
||||
Value = ENRS.Value.Invalid;
|
||||
if (Val < 0x00000040) Value = ENRS.Value.Int8 ;
|
||||
else if (Val < 0x00004000) Value = ENRS.Value.Int16;
|
||||
else if (Val < 0x40000000) Value = ENRS.Value.Int32;
|
||||
*ptr = (byte)(((byte)Value << 6) & 0xC0);
|
||||
|
||||
if (Val < 0x00000040)
|
||||
{ *ptr |= (byte)( Val & 0x3F); }
|
||||
else if (Val < 0x00004000)
|
||||
{ *ptr |= (byte)((Val >> 8) & 0x3F); ptr++;
|
||||
*ptr = (byte)( Val & 0xFF); }
|
||||
else if (Val < 0x40000000)
|
||||
{ *ptr |= (byte)((Val >> 24) & 0x3F); ptr++;
|
||||
*ptr = (byte)((Val >> 16) & 0xFF); ptr++;
|
||||
*ptr = (byte)((Val >> 8) & 0xFF); ptr++;
|
||||
*ptr = (byte)( Val & 0xFF); }
|
||||
ptr++;
|
||||
}
|
||||
|
||||
public struct ENRS
|
||||
{
|
||||
public int Offset;
|
||||
public int Count;
|
||||
public int Size;
|
||||
public int Repeat;
|
||||
public KKdList<SubENRS> Sub;
|
||||
|
||||
public enum Type : byte
|
||||
{
|
||||
WORD = 0b00,
|
||||
DWORD = 0b01,
|
||||
QWORD = 0b10,
|
||||
Invalid = 0b11,
|
||||
}
|
||||
|
||||
public enum Value : byte
|
||||
{
|
||||
Int8 = 0b00,
|
||||
Int16 = 0b01,
|
||||
Int32 = 0b10,
|
||||
Invalid = 0b11,
|
||||
}
|
||||
|
||||
public struct SubENRS
|
||||
{
|
||||
public int Skip;
|
||||
public int Reverse;
|
||||
public Type Type;
|
||||
|
||||
public int SizeSkip => Skip + Reverse * (2 << (byte)Type);
|
||||
public int Size => Reverse * (2 << (byte)Type);
|
||||
|
||||
public override string ToString() => "Skip: " + Skip + "; Reverse: " + Reverse + "; Type: " + Type;
|
||||
}
|
||||
|
||||
public override string ToString() =>
|
||||
"Offset: " + Offset + "; Count: " + Count + "; " + "Size: " + Size + "; Repeat: " + Repeat;
|
||||
}
|
||||
|
||||
public override string ToString() =>
|
||||
$"ID: {ID}{(NotNull ? $"; ENRS Count: {List.Count}" : "")}{(EOFC ? "; Has EOFC" : "")}";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
namespace KKdBaseLib.F2
|
||||
{
|
||||
public struct Header
|
||||
{
|
||||
public int Signature;
|
||||
public int DataSize;
|
||||
public int Length;
|
||||
public int Flags;
|
||||
public int ID;
|
||||
public int SectionSize;
|
||||
public int Mode;
|
||||
public int InnerSignature;
|
||||
public int SectionSignature;
|
||||
|
||||
public Format Format;
|
||||
public bool NotUseDataSizeAsSectionSize;
|
||||
|
||||
public bool IsBE => Format == Format.F2BE;
|
||||
public bool IsX => Format == Format.X || Format == Format.XHD;
|
||||
|
||||
public override string ToString() => Signature.ToString(false);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,91 @@
|
||||
namespace KKdBaseLib.F2
|
||||
{
|
||||
public unsafe struct POF
|
||||
{
|
||||
public int ID;
|
||||
public bool EOFC;
|
||||
public KKdList<long> Offsets;
|
||||
|
||||
public bool IsNull => Offsets. IsNull;
|
||||
public bool NotNull => Offsets.NotNull;
|
||||
|
||||
public static POF Read(byte[] data, bool ShiftX, int ID = 0, bool EOFC = false)
|
||||
{
|
||||
Value Val = 0;
|
||||
KKdList<long> Offsets = KKdList<long>.New;
|
||||
byte* ptr = data.GetPtr();
|
||||
int i = 0, Offset = 0, V = 0;
|
||||
byte BitShift = (byte)(ShiftX ? 3 : 2);
|
||||
|
||||
int Length = *(int*)ptr - 4; ptr += 4;
|
||||
while (Length > i)
|
||||
{
|
||||
V = *ptr & 0x3F;
|
||||
Val = (Value)(*ptr & 0xC0);
|
||||
ptr++; i++;
|
||||
if (Val == Value.Int32 )
|
||||
{ V = (V << 24) | (ptr[0] << 16) | (ptr[1] << 8) | ptr[2]; ptr += 3; i += 3; }
|
||||
else if (Val == Value.Int16 )
|
||||
{ V = (V << 8) | ptr[0]; ptr += 1; i += 3; }
|
||||
else if (Val == Value.Invalid) break;
|
||||
Offset += V;
|
||||
Offsets.Add(Offset << BitShift);
|
||||
}
|
||||
return new POF { EOFC = EOFC, ID = ID, Offsets = Offsets };
|
||||
}
|
||||
|
||||
public static byte[] Write(POF POF, bool ShiftX)
|
||||
{
|
||||
POF.Offsets.Sort();
|
||||
int Length = 5;
|
||||
long Offset = 0;
|
||||
byte BitShift = (byte)(ShiftX ? 3 : 2);
|
||||
int Max1 = 0x00FF >> BitShift;
|
||||
int Max2 = 0xFFFF >> BitShift;
|
||||
for (int i = 0; i < POF.Offsets.Count; i++)
|
||||
{
|
||||
Offset = POF.Offsets[i];
|
||||
if (i > 0) { Offset -= POF.Offsets[i - 1]; if (Offset == 0) continue; }
|
||||
|
||||
Offset >>= BitShift;
|
||||
if (Offset <= Max1) Length += 1;
|
||||
else if (Offset <= Max2) Length += 2;
|
||||
else Length += 4;
|
||||
}
|
||||
|
||||
byte[] data = new byte[Length.Align(0x10)];
|
||||
byte* ptr = data.GetPtr();
|
||||
|
||||
byte Val = 0;
|
||||
*(int*)ptr = Length; ptr += 4;
|
||||
for (int i = 0; i < POF.Offsets.Count; i++)
|
||||
{
|
||||
Offset = POF.Offsets[i];
|
||||
if (i > 0) { Offset -= POF.Offsets[i - 1]; if (Offset == 0) continue; }
|
||||
|
||||
Offset >>= BitShift;
|
||||
Val = (byte)(Offset > Max2 ? Value.Int32 : Offset > Max1 ? Value.Int16 : Value.Int8);
|
||||
if (Offset <= Max1) *ptr = (byte)(Val | Offset );
|
||||
else if (Offset <= Max2) { *ptr = (byte)(Val | (Offset >> 8)); ptr++;
|
||||
*ptr = (byte) Offset ; }
|
||||
else { *ptr = (byte)(Val | (Offset >> 24)); ptr++;
|
||||
*ptr = (byte) (Offset >> 16) ; ptr++;
|
||||
*ptr = (byte) (Offset >> 8) ; ptr++;
|
||||
*ptr = (byte) Offset ; }
|
||||
ptr++;
|
||||
}
|
||||
return data;
|
||||
}
|
||||
|
||||
public enum Value : byte
|
||||
{
|
||||
Invalid = 0b00000000,
|
||||
Int8 = 0b01000000,
|
||||
Int16 = 0b10000000,
|
||||
Int32 = 0b11000000,
|
||||
}
|
||||
|
||||
public override string ToString() =>
|
||||
$"ID: {ID}{(NotNull ? $"; Offsets Count: {Offsets.Count}" : "")}{(EOFC ? "; Has EOFC" : "")}";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
namespace KKdBaseLib.F2
|
||||
{
|
||||
public struct Struct
|
||||
{
|
||||
public Header Header;
|
||||
public byte[] Data;
|
||||
public Struct[] SubStructs;
|
||||
|
||||
public bool EOFC;
|
||||
public ENRSList ENRS;
|
||||
public POF POF;
|
||||
|
||||
public int ID => Header.ID;
|
||||
|
||||
public bool HasPOF => POF .NotNull;
|
||||
public bool HasENRS => ENRS.NotNull;
|
||||
public bool HasSubStructs => SubStructs != null;
|
||||
|
||||
public long DataOffset;
|
||||
|
||||
public override string ToString() => $"{Header.ToString()}" +
|
||||
$"{(HasSubStructs ? $"; SubStructs: {SubStructs.Length}" : "")}" +
|
||||
$"{(HasENRS ? "; Has ENRS" : "")}{(HasPOF ? "; Has POF" : "")}{(EOFC ? "; Has EOFC" : "")}";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
namespace KKdBaseLib
|
||||
{
|
||||
public enum Format : byte
|
||||
{
|
||||
NULL = 0,
|
||||
DT = 1,
|
||||
PDA = 2,
|
||||
DT2 = 3,
|
||||
DTe = 4,
|
||||
F = 5,
|
||||
FT = 6,
|
||||
F2LE = 7,
|
||||
F2BE = 8,
|
||||
MGF = 9,
|
||||
X = 10,
|
||||
XHD = 11,
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,87 @@
|
||||
using System;
|
||||
|
||||
namespace KKdBaseLib
|
||||
{
|
||||
public struct Half : IFormattable
|
||||
{
|
||||
private ushort _value;
|
||||
|
||||
public static Half NaN => new Half { _value = 0x7FFF };
|
||||
public static Half PositiveNaN => new Half { _value = 0x7FFF };
|
||||
public static Half NegativeNaN => new Half { _value = 0xFFFF };
|
||||
public static Half PositiveZero => new Half { _value = 0x0000 };
|
||||
public static Half NegativeZero => new Half { _value = 0x8000 };
|
||||
public static Half PositiveInfinity => new Half { _value = 0x7C00 };
|
||||
public static Half NegativeInfinity => new Half { _value = 0xFC00 };
|
||||
|
||||
public static explicit operator Half(ushort bits) => new Half() { _value = bits };
|
||||
|
||||
public static explicit operator ushort(Half bits) => bits._value;
|
||||
|
||||
public static unsafe implicit operator float(Half h)
|
||||
{
|
||||
int sign = (h._value >> 15) & 0x001;
|
||||
int exponent = ((h._value >> 10) & 0x01F) + 127 - 15;
|
||||
int mantissa = h._value & 0x3FF;
|
||||
|
||||
int si32 = (sign << 31) | (exponent << 23) | (mantissa << 13);
|
||||
return *(float*)&si32;
|
||||
}
|
||||
|
||||
public static unsafe implicit operator Half(float val)
|
||||
{
|
||||
int si32 = *(int*)&val;
|
||||
ushort sign = (ushort)( (si32 >> 16) & 0x8000);
|
||||
short exponent = ( short)(((si32 >> 23) & 0x00FF) - 127 + 15);
|
||||
ushort mantissa = (ushort)( (si32 >> 13) & 0x03FF);
|
||||
|
||||
if (exponent < 0) { exponent = 0; mantissa = 0; }
|
||||
else if (exponent > 30) exponent = 31;
|
||||
|
||||
return new Half { _value = (ushort)(sign | (exponent << 10) | mantissa) };
|
||||
}
|
||||
|
||||
public static unsafe implicit operator double(Half h)
|
||||
{
|
||||
int sign = (h._value >> 15) & 0x001;
|
||||
int exponent = ((h._value >> 10) & 0x01F) + 1023 - 15;
|
||||
int mantissa = h._value & 0x3FF;
|
||||
|
||||
long si64 = ((long)sign << 63) | ((long)exponent << 52) | ((long)mantissa << 42);
|
||||
return *(double*)&si64;
|
||||
}
|
||||
|
||||
public static unsafe implicit operator Half(double val)
|
||||
{
|
||||
long si64 = *(long*)&val;
|
||||
ushort sign = (ushort) ((si64 >> 48) & 0x8000);
|
||||
short exponent = ( short)(((si64 >> 52) & 0x07FF) - 1023 + 15);
|
||||
ushort mantissa = (ushort) ((si64 >> 42) & 0x03FF);
|
||||
|
||||
if (exponent < 0) { exponent = 0; mantissa = 0; }
|
||||
else if (exponent > 30) exponent = 31;
|
||||
|
||||
return new Half { _value = (ushort)(sign | (exponent << 10) | mantissa) };
|
||||
}
|
||||
|
||||
public static Half operator + (Half a, Half b) => (float)a + (float)b;
|
||||
public static Half operator - (Half a, Half b) => (float)a - (float)b;
|
||||
public static Half operator * (Half a, Half b) => (float)a * (float)b;
|
||||
public static Half operator / (Half a, Half b) => (float)a / (float)b;
|
||||
public static bool operator > (Half a, Half b) => (float)a > (float)b;
|
||||
public static bool operator < (Half a, Half b) => (float)a < (float)b;
|
||||
public static bool operator >=(Half a, Half b) => (float)a >= (float)b;
|
||||
public static bool operator <=(Half a, Half b) => (float)a <= (float)b;
|
||||
public static bool operator ==(Half a, Half b) => (float)a == (float)b;
|
||||
public static bool operator !=(Half a, Half b) => (float)a != (float)b;
|
||||
|
||||
public int CompareTo(object obj) => CompareTo((Half)obj);
|
||||
public int CompareTo(Half h) => this == h ? 0 : (this > h ? 1 : -1);
|
||||
public bool Equals(Half other) => this == other;
|
||||
public override bool Equals(object obj) => base.Equals(obj);
|
||||
public override string ToString() => Extensions.ToString((double)this);
|
||||
public string ToString(string format, IFormatProvider formatProvider) =>
|
||||
((float)this).ToString(format, formatProvider);
|
||||
public override int GetHashCode() => base.GetHashCode();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,148 @@
|
||||
namespace KKdBaseLib
|
||||
{
|
||||
public interface IKF<TKey, TVal>
|
||||
{
|
||||
TKey F { get; set; }
|
||||
|
||||
KFT0<TKey, TVal> ToT0();
|
||||
KFT1<TKey, TVal> ToT1();
|
||||
KFT2<TKey, TVal> ToT2();
|
||||
KFT3<TKey, TVal> ToT3();
|
||||
|
||||
IKF<TKey, TVal> Check();
|
||||
string ToString();
|
||||
string ToString(bool Brackets);
|
||||
}
|
||||
|
||||
public struct KFT0<TKey, TVal> : IKF<TKey, TVal>
|
||||
{
|
||||
public TKey F { get; set; }
|
||||
|
||||
public KFT0(TKey F = default)
|
||||
{ this.F = F; }
|
||||
|
||||
public KFT0<TKey, TVal> ToT0() => this;
|
||||
public KFT1<TKey, TVal> ToT1() => this;
|
||||
public KFT2<TKey, TVal> ToT2() => this;
|
||||
public KFT3<TKey, TVal> ToT3() => this;
|
||||
|
||||
public IKF<TKey, TVal> Check() => this;
|
||||
|
||||
public override string ToString() => ToString(true);
|
||||
public string ToString(bool Brackets = true) =>
|
||||
Extensions.ToString(F);
|
||||
|
||||
public static implicit operator KFT1<TKey, TVal>(KFT0<TKey, TVal> KF) =>
|
||||
new KFT1<TKey, TVal>(KF.F);
|
||||
public static implicit operator KFT2<TKey, TVal>(KFT0<TKey, TVal> KF) =>
|
||||
new KFT2<TKey, TVal>(KF.F);
|
||||
public static implicit operator KFT3<TKey, TVal>(KFT0<TKey, TVal> KF) =>
|
||||
new KFT3<TKey, TVal>(KF.F);
|
||||
}
|
||||
|
||||
public struct KFT1<TKey, TVal> : IKF<TKey, TVal>
|
||||
{
|
||||
public TKey F { get; set; }
|
||||
public TVal V;
|
||||
|
||||
public KFT1(TKey F = default, TVal V = default)
|
||||
{ this.F = F; this.V = V; }
|
||||
|
||||
public KFT0<TKey, TVal> ToT0() => this;
|
||||
public KFT1<TKey, TVal> ToT1() => this;
|
||||
public KFT2<TKey, TVal> ToT2() => this;
|
||||
public KFT3<TKey, TVal> ToT3() => this;
|
||||
|
||||
public IKF<TKey, TVal> Check() =>
|
||||
V.Equals(default(TVal)) ? (KFT0<TKey, TVal>)this : (IKF<TKey, TVal>)this;
|
||||
|
||||
public override string ToString() => ToString(true);
|
||||
public string ToString(bool Brackets = true) =>
|
||||
(Brackets ? "(" : "") + Extensions.ToString(F) + "," +
|
||||
Extensions.ToString(V) + (Brackets ? ")" : "");
|
||||
|
||||
public static implicit operator KFT0<TKey, TVal>(KFT1<TKey, TVal> KF) =>
|
||||
new KFT0<TKey, TVal>(KF.F);
|
||||
public static implicit operator KFT2<TKey, TVal>(KFT1<TKey, TVal> KF) =>
|
||||
new KFT2<TKey, TVal>(KF.F, KF.V);
|
||||
public static implicit operator KFT3<TKey, TVal>(KFT1<TKey, TVal> KF) =>
|
||||
new KFT3<TKey, TVal>(KF.F, KF.V);
|
||||
}
|
||||
|
||||
public struct KFT2<TKey, TVal> : IKF<TKey, TVal>
|
||||
{
|
||||
public TKey F { get; set; }
|
||||
public TVal V;
|
||||
public TVal T;
|
||||
|
||||
public KFT2(TKey F = default, TVal V = default, TVal T = default)
|
||||
{ this.F = F; this.V = V; this.T = T; }
|
||||
|
||||
public KFT0<TKey, TVal> ToT0() => this;
|
||||
public KFT1<TKey, TVal> ToT1() => this;
|
||||
public KFT2<TKey, TVal> ToT2() => this;
|
||||
public KFT3<TKey, TVal> ToT3() => this;
|
||||
|
||||
public KFT3<TKey, TVal> ToT3(IKF<TKey, TVal> Previous) =>
|
||||
Previous is KFT2<TKey, TVal> PreviousT2 ?
|
||||
new KFT3<TKey, TVal>(F, V, PreviousT2.T, T) :
|
||||
new KFT3<TKey, TVal>(F, V, T, T);
|
||||
|
||||
public IKF<TKey, TVal> Check() =>
|
||||
T.Equals(default(TVal)) ? (V.Equals(default(TVal)) ?
|
||||
(KFT0<TKey, TVal>)this : (IKF<TKey, TVal>)this) : this;
|
||||
|
||||
public override string ToString() => ToString(true);
|
||||
public string ToString(bool Brackets) =>
|
||||
(Brackets ? "(" : "") + Extensions.ToString(F) + "," + Extensions.
|
||||
ToString(V) + "," + Extensions.ToString(T) + (Brackets ? ")" : "");
|
||||
|
||||
public static implicit operator KFT0<TKey, TVal>(KFT2<TKey, TVal> KF) =>
|
||||
new KFT0<TKey, TVal>(KF.F);
|
||||
public static implicit operator KFT1<TKey, TVal>(KFT2<TKey, TVal> KF) =>
|
||||
new KFT1<TKey, TVal>(KF.F, KF.V);
|
||||
public static implicit operator KFT3<TKey, TVal>(KFT2<TKey, TVal> KF) =>
|
||||
new KFT3<TKey, TVal>(KF.F, KF.V, KF.T, KF.T);
|
||||
}
|
||||
|
||||
public struct KFT3<TKey, TVal> : IKF<TKey, TVal>
|
||||
{
|
||||
public TKey F { get; set; }
|
||||
public TVal V;
|
||||
public TVal T1;
|
||||
public TVal T2;
|
||||
|
||||
public KFT3(TKey F = default, TVal V = default, TVal T1 = default, TVal T2 = default)
|
||||
{ this.F = F; this.V = V; this.T1 = T1; this.T2 = T2; }
|
||||
|
||||
public KFT0<TKey, TVal> ToT0() => this;
|
||||
public KFT1<TKey, TVal> ToT1() => this;
|
||||
public KFT2<TKey, TVal> ToT2() => this;
|
||||
public KFT3<TKey, TVal> ToT3() => this;
|
||||
|
||||
public IKF<TKey, TVal> Check() =>
|
||||
T1.Equals(default(TVal)) && T2.Equals(default(TVal)) ?
|
||||
(V.Equals(default(TVal)) ? (KFT0<TKey, TVal>)this : (IKF<TKey, TVal>)this) :
|
||||
T1.Equals(T2) ? (KFT2<TKey, TVal>)this : (IKF<TKey, TVal>)this;
|
||||
|
||||
public override string ToString() => ToString(true);
|
||||
public string ToString(bool Brackets) =>
|
||||
(Brackets ? "(" : "") + Extensions.ToString(F) + "," + Extensions.ToString(V) + "," +
|
||||
Extensions.ToString(T1) + "," + Extensions.ToString(T2) + (Brackets ? ")" : "");
|
||||
|
||||
public static implicit operator KFT0<TKey, TVal>(KFT3<TKey, TVal> KF) =>
|
||||
new KFT0<TKey, TVal>(KF.F);
|
||||
public static implicit operator KFT1<TKey, TVal>(KFT3<TKey, TVal> KF) =>
|
||||
new KFT1<TKey, TVal>(KF.F, KF.V);
|
||||
public static implicit operator KFT2<TKey, TVal>(KFT3<TKey, TVal> KF) =>
|
||||
new KFT2<TKey, TVal>(KF.F, KF.V, KF.T1);
|
||||
|
||||
public IKF<TKey, TVal> ToT2(IKF<TKey, TVal> Previous, out IKF<TKey, TVal> Current)
|
||||
{
|
||||
Current = Previous is KFT2<TKey, TVal> PreviousT2
|
||||
? new KFT2<TKey, TVal>(PreviousT2.F, PreviousT2.V, T1)
|
||||
: new KFT2<TKey, TVal>(F, V, T1);
|
||||
return new KFT2<TKey, TVal>(F, V, T2);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,67 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
|
||||
<PropertyGroup>
|
||||
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
|
||||
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
|
||||
<ProjectGuid>{437F63F1-8C23-429E-AB14-38B85C9EDB16}</ProjectGuid>
|
||||
<OutputType>Library</OutputType>
|
||||
<RootNamespace>KKdBaseLib</RootNamespace>
|
||||
<AssemblyName>KKdBaseLib</AssemblyName>
|
||||
<TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
|
||||
<FileAlignment>512</FileAlignment>
|
||||
<Deterministic>true</Deterministic>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
|
||||
<PlatformTarget>AnyCPU</PlatformTarget>
|
||||
<DebugSymbols>true</DebugSymbols>
|
||||
<DebugType>full</DebugType>
|
||||
<Optimize>false</Optimize>
|
||||
<OutputPath>bin\</OutputPath>
|
||||
<DefineConstants>DEBUG;TRACE</DefineConstants>
|
||||
<ErrorReport>prompt</ErrorReport>
|
||||
<WarningLevel>4</WarningLevel>
|
||||
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
|
||||
<LangVersion>7.3</LangVersion>
|
||||
<NoWarn>IDE0044, IDE0045, IDE0046, IDE0055, IDE0059, IDE1006</NoWarn>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
|
||||
<PlatformTarget>AnyCPU</PlatformTarget>
|
||||
<DebugType>embedded</DebugType>
|
||||
<Optimize>true</Optimize>
|
||||
<OutputPath>bin\</OutputPath>
|
||||
<DefineConstants>TRACE</DefineConstants>
|
||||
<ErrorReport>prompt</ErrorReport>
|
||||
<WarningLevel>4</WarningLevel>
|
||||
<DebugSymbols>true</DebugSymbols>
|
||||
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
|
||||
<LangVersion>7.3</LangVersion>
|
||||
<NoWarn>IDE0044, IDE0045, IDE0046, IDE0055, IDE0059, IDE1006</NoWarn>
|
||||
</PropertyGroup>
|
||||
<ItemGroup>
|
||||
<Compile Include="F2\ENRS.cs" />
|
||||
<Compile Include="F2\Header.cs" />
|
||||
<Compile Include="F2\POF.cs" />
|
||||
<Compile Include="F2\Struct.cs" />
|
||||
<Compile Include="DCC.cs" />
|
||||
<Compile Include="Extensions.cs" />
|
||||
<Compile Include="Format.cs" />
|
||||
<Compile Include="Half.cs" />
|
||||
<Compile Include="IKF.cs" />
|
||||
<Compile Include="KKdList.cs" />
|
||||
<Compile Include="MsgPack.cs" />
|
||||
<Compile Include="Pointer.cs" />
|
||||
<Compile Include="Text.cs" />
|
||||
<Compile Include="Vector.cs" />
|
||||
<Compile Include="Vector3.cs" />
|
||||
<Compile Include="Vector4.cs" />
|
||||
<Compile Include="Properties\AssemblyInfo.cs" />
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<Reference Include="System" />
|
||||
<Reference Include="System.Drawing" />
|
||||
<Reference Include="System.Numerics" />
|
||||
<Reference Include="System.Windows.Forms" />
|
||||
</ItemGroup>
|
||||
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
|
||||
</Project>
|
||||
@@ -0,0 +1,114 @@
|
||||
using System.Collections;
|
||||
using System.Collections.Generic;
|
||||
|
||||
namespace KKdBaseLib
|
||||
{
|
||||
public struct KKdList<T> : System.IDisposable, IEnumerator, IEnumerable
|
||||
{
|
||||
public static KKdList<T> Null => new KKdList<T>();
|
||||
public static KKdList<T> New => new KKdList<T>() { Capacity = 0 };
|
||||
public static KKdList<T> NewReserve(int Capacity) => new KKdList<T>() { Capacity = Capacity };
|
||||
|
||||
private int index;
|
||||
private T[] array;
|
||||
|
||||
public int Count { get; private set; }
|
||||
|
||||
public bool IsNull => array == null;
|
||||
public bool NotNull => array != null;
|
||||
|
||||
public int Capacity { get => array != null ? array.Length : -1;
|
||||
set { if (array != null) System.Array.Resize(ref array, value); else array = new T[value];
|
||||
if (Count >= value) Count = value; } }
|
||||
|
||||
|
||||
public KKdList(T[] Array)
|
||||
{ index = 0; Count = Array.Length; array = Array; }
|
||||
|
||||
public T Current => index < Count ? array[index] : default;
|
||||
|
||||
object IEnumerator.Current => Current;
|
||||
|
||||
public T this[ int index]
|
||||
{ get => array != null ? array[index] : default;
|
||||
set { if (array != null) array[index] = value; } }
|
||||
|
||||
public T this[uint index]
|
||||
{ get => array != null ? array[index] : default;
|
||||
set { if (array != null) array[index] = value; } }
|
||||
|
||||
public bool MoveNext()
|
||||
{ if (index == (Count - 1)) { index = 0; return false; }
|
||||
else { index++ ; return true; } }
|
||||
|
||||
public IEnumerator GetEnumerator() => this;
|
||||
|
||||
public void Dispose() { array = null; Count = 0; index = 0; }
|
||||
|
||||
public void Reset() => index = 0;
|
||||
|
||||
public void Add(T item)
|
||||
{
|
||||
if (IsNull) return;
|
||||
|
||||
Count++;
|
||||
if (array.Length < Count)
|
||||
System.Array.Resize(ref array, Count);
|
||||
array[Count - 1] = item;
|
||||
}
|
||||
|
||||
public void RemoveAt(int index)
|
||||
{
|
||||
if (IsNull) return;
|
||||
|
||||
for (int i = index + 1; i < Count; i++)
|
||||
array[i - 1] = array[i];
|
||||
Count--;
|
||||
}
|
||||
|
||||
public void RemoveRange(int IndexStart, int IndexEnd)
|
||||
{
|
||||
if (IsNull) return;
|
||||
if (IndexEnd - IndexStart < 1) return;
|
||||
|
||||
for (int i = IndexStart; i < Count; i++)
|
||||
array[i] = array[i + IndexEnd - IndexStart];
|
||||
Count -= IndexEnd - IndexStart;
|
||||
}
|
||||
|
||||
public T[] ToArray() => array;
|
||||
|
||||
public bool Contains(T val)
|
||||
{
|
||||
if (IsNull) return false;
|
||||
for (int i = 0; i < Count; i++)
|
||||
if (array[i] == null && val == null) return true;
|
||||
else if (array[i] == null || val == null) continue;
|
||||
else if (array[i] .Equals(val) ) return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
public int IndexOf(T val)
|
||||
{
|
||||
if (IsNull) return -1;
|
||||
for (int i = 0; i < Count; i++)
|
||||
if (array[i] == null && val == null) return i;
|
||||
else if (array[i] == null || val == null) continue;
|
||||
else if (array[i] .Equals(val) ) return i;
|
||||
return -1;
|
||||
}
|
||||
|
||||
public void Sort()
|
||||
{ List<T> List = this; List.Sort(); array = List.ToArray(); Count = List.Count; }
|
||||
|
||||
public static implicit operator KKdList<T>( List<T> List) =>
|
||||
new KKdList<T> { array = List.ToArray(), Count = List.Count };
|
||||
|
||||
public static implicit operator List<T>(KKdList<T> List)
|
||||
{
|
||||
List<T> list = new List<T>();
|
||||
for (int i = 0; i < List.Count; i++) list.Add(List[i]);
|
||||
return list;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,357 @@
|
||||
using System;
|
||||
|
||||
namespace KKdBaseLib
|
||||
{
|
||||
public struct MsgPack : IDisposable, IEquatable<MsgPack>
|
||||
{
|
||||
public string Name;
|
||||
public object Object;
|
||||
|
||||
public MsgPack[] Array => Object is MsgPack[] List ? List : null;
|
||||
public KKdList<MsgPack> List => Object is KKdList<MsgPack> List ? List : default;
|
||||
|
||||
public static MsgPack New => new MsgPack { Object = KKdList<MsgPack>.New };
|
||||
public static MsgPack NewReserve(int Capacity) =>
|
||||
new MsgPack { Object = KKdList<MsgPack>.NewReserve(Capacity) };
|
||||
|
||||
public MsgPack( string Name = null)
|
||||
{ Object = KKdList<MsgPack>.New; this.Name = Name; }
|
||||
|
||||
public MsgPack(long Count, string Name = null)
|
||||
{ Object = Count > 0 ? new MsgPack[Count] : null; this.Name = Name; }
|
||||
|
||||
public MsgPack(string Name, object Object)
|
||||
{ this.Name = Name; this.Object = Object; }
|
||||
|
||||
public static MsgPack Null => new MsgPack();
|
||||
|
||||
public MsgPack this[int index]
|
||||
{ get => Object is MsgPack[] Array ? Array[index] : default;
|
||||
set { if (Object is MsgPack[] Array) { Array[index] = value; Object = Array; } } }
|
||||
|
||||
public MsgPack Add(MsgPack obj)
|
||||
{ if (Object is KKdList<MsgPack> List) { List.Add(obj); Object = List; } return this; }
|
||||
|
||||
public void Dispose()
|
||||
{ Name = null; Object = null; }
|
||||
|
||||
public bool Equals(MsgPack msg) =>
|
||||
Name == msg.Name && Object == msg.Object;
|
||||
|
||||
public override string ToString() => Name ?? "" +
|
||||
(List. NotNull ? ((Name != null ? " " : "") + "Elements Count: " + List .Count ) :
|
||||
(Array != null ? ((Name != null ? " " : "") + "Elements Count: " + Array.Length) :
|
||||
Object.ToString()));
|
||||
|
||||
public static implicit operator MsgPack(byte[] val) => new MsgPack(null, val);
|
||||
public static implicit operator MsgPack(string val) => new MsgPack(null, val);
|
||||
public static implicit operator MsgPack( sbyte val) => new MsgPack(null, val);
|
||||
public static implicit operator MsgPack( byte val) => new MsgPack(null, val);
|
||||
public static implicit operator MsgPack( short val) => new MsgPack(null, val);
|
||||
public static implicit operator MsgPack(ushort val) => new MsgPack(null, val);
|
||||
public static implicit operator MsgPack( int val) => new MsgPack(null, val);
|
||||
public static implicit operator MsgPack( uint val) => new MsgPack(null, val);
|
||||
public static implicit operator MsgPack( long val) => new MsgPack(null, val);
|
||||
public static implicit operator MsgPack( ulong val) => new MsgPack(null, val);
|
||||
public static implicit operator MsgPack( float val) => new MsgPack(null, val);
|
||||
public static implicit operator MsgPack(double val) => new MsgPack(null, val);
|
||||
|
||||
public MsgPack Add( bool? val) => val.HasValue ? Add(new MsgPack(null, val.Value)) : this;
|
||||
public MsgPack Add( sbyte? val) => val.HasValue ? Add(new MsgPack(null, val.Value)) : this;
|
||||
public MsgPack Add( byte? val) => val.HasValue ? Add(new MsgPack(null, val.Value)) : this;
|
||||
public MsgPack Add( short? val) => val.HasValue ? Add(new MsgPack(null, val.Value)) : this;
|
||||
public MsgPack Add(ushort? val) => val.HasValue ? Add(new MsgPack(null, val.Value)) : this;
|
||||
public MsgPack Add( int? val) => val.HasValue ? Add(new MsgPack(null, val.Value)) : this;
|
||||
public MsgPack Add( uint? val) => val.HasValue ? Add(new MsgPack(null, val.Value)) : this;
|
||||
public MsgPack Add( long? val) => val.HasValue ? Add(new MsgPack(null, val.Value)) : this;
|
||||
public MsgPack Add( ulong? val) => val.HasValue ? Add(new MsgPack(null, val.Value)) : this;
|
||||
public MsgPack Add( float? val) => val.HasValue ? Add(new MsgPack(null, val.Value)) : this;
|
||||
public MsgPack Add(double? val) => val.HasValue ? Add(new MsgPack(null, val.Value)) : this;
|
||||
|
||||
public MsgPack Add(byte[] val) => Add(new MsgPack(null, val));
|
||||
public MsgPack Add(string val) => Add(new MsgPack(null, val));
|
||||
public MsgPack Add( bool val) => Add(new MsgPack(null, val));
|
||||
public MsgPack Add( sbyte val) => Add(new MsgPack(null, val));
|
||||
public MsgPack Add( byte val) => Add(new MsgPack(null, val));
|
||||
public MsgPack Add( short val) => Add(new MsgPack(null, val));
|
||||
public MsgPack Add(ushort val) => Add(new MsgPack(null, val));
|
||||
public MsgPack Add( int val) => Add(new MsgPack(null, val));
|
||||
public MsgPack Add( uint val) => Add(new MsgPack(null, val));
|
||||
public MsgPack Add( long val) => Add(new MsgPack(null, val));
|
||||
public MsgPack Add( ulong val) => Add(new MsgPack(null, val));
|
||||
public MsgPack Add( float val) => Add(new MsgPack(null, val));
|
||||
public MsgPack Add(double val) => Add(new MsgPack(null, val));
|
||||
|
||||
public MsgPack Add(string Val, bool? val) => val.HasValue ? Add(Val, val.Value) : this;
|
||||
public MsgPack Add(string Val, sbyte? val) => val.HasValue ? Add(Val, val.Value) : this;
|
||||
public MsgPack Add(string Val, byte? val) => val.HasValue ? Add(Val, val.Value) : this;
|
||||
public MsgPack Add(string Val, short? val) => val.HasValue ? Add(Val, val.Value) : this;
|
||||
public MsgPack Add(string Val, ushort? val) => val.HasValue ? Add(Val, val.Value) : this;
|
||||
public MsgPack Add(string Val, int? val) => val.HasValue ? Add(Val, val.Value) : this;
|
||||
public MsgPack Add(string Val, uint? val) => val.HasValue ? Add(Val, val.Value) : this;
|
||||
public MsgPack Add(string Val, long? val) => val.HasValue ? Add(Val, val.Value) : this;
|
||||
public MsgPack Add(string Val, ulong? val) => val.HasValue ? Add(Val, val.Value) : this;
|
||||
public MsgPack Add(string Val, float? val) => val.HasValue ? Add(Val, val.Value) : this;
|
||||
public MsgPack Add(string Val, double? val) => val.HasValue ? Add(Val, val.Value) : this;
|
||||
|
||||
public MsgPack Add(string Val, byte[] val) => Add(new MsgPack(Val, val));
|
||||
public MsgPack Add(string Val, string val) => Add(new MsgPack(Val, val));
|
||||
public MsgPack Add(string Val, bool val) => Add(new MsgPack(Val, val));
|
||||
public MsgPack Add(string Val, sbyte val) => Add(new MsgPack(Val, val));
|
||||
public MsgPack Add(string Val, byte val) => Add(new MsgPack(Val, val));
|
||||
public MsgPack Add(string Val, short val) => Add(new MsgPack(Val, val));
|
||||
public MsgPack Add(string Val, ushort val) => Add(new MsgPack(Val, val));
|
||||
public MsgPack Add(string Val, int val) => Add(new MsgPack(Val, val));
|
||||
public MsgPack Add(string Val, uint val) => Add(new MsgPack(Val, val));
|
||||
public MsgPack Add(string Val, long val) => Add(new MsgPack(Val, val));
|
||||
public MsgPack Add(string Val, ulong val) => Add(new MsgPack(Val, val));
|
||||
public MsgPack Add(string Val, float val) => Add(new MsgPack(Val, val));
|
||||
public MsgPack Add(string Val, double val) => Add(new MsgPack(Val, val));
|
||||
|
||||
public bool ReadBoolean(string Name) => ReadNBoolean(Name).GetValueOrDefault();
|
||||
public sbyte ReadInt8(string Name) => ReadNInt8(Name).GetValueOrDefault();
|
||||
public byte ReadUInt8(string Name) => ReadNUInt8(Name).GetValueOrDefault();
|
||||
public short ReadInt16(string Name) => ReadNInt16(Name).GetValueOrDefault();
|
||||
public ushort ReadUInt16(string Name) => ReadNUInt16(Name).GetValueOrDefault();
|
||||
public int ReadInt32(string Name) => ReadNInt32(Name).GetValueOrDefault();
|
||||
public uint ReadUInt32(string Name) => ReadNUInt32(Name).GetValueOrDefault();
|
||||
public long ReadInt64(string Name) => ReadNInt64(Name).GetValueOrDefault();
|
||||
public ulong ReadUInt64(string Name) => ReadNUInt64(Name).GetValueOrDefault();
|
||||
public float ReadSingle(string Name) => ReadNSingle(Name).GetValueOrDefault();
|
||||
public double ReadDouble(string Name) => ReadNDouble(Name).GetValueOrDefault();
|
||||
|
||||
public bool? ReadNBoolean(string Name)
|
||||
{
|
||||
if (Element(Name, out MsgPack MsgPack))
|
||||
if (MsgPack.Object is bool Boolean) return Boolean;
|
||||
return null;
|
||||
}
|
||||
public sbyte? ReadNInt8(string Name)
|
||||
{
|
||||
if (Element(Name, out MsgPack MsgPack))
|
||||
if (MsgPack.Object is sbyte Int8 ) return Int8 ;
|
||||
else if (MsgPack.Object is byte UInt8 ) return ( sbyte) UInt8 ;
|
||||
return null;
|
||||
}
|
||||
public byte? ReadNUInt8(string Name)
|
||||
{
|
||||
if (Element(Name, out MsgPack MsgPack))
|
||||
if (MsgPack.Object is sbyte Int8 ) return ( byte) Int8 ;
|
||||
else if (MsgPack.Object is byte UInt8 ) return UInt8 ;
|
||||
return null;
|
||||
}
|
||||
public short? ReadNInt16(string Name)
|
||||
{
|
||||
if (Element(Name, out MsgPack MsgPack))
|
||||
if (MsgPack.Object is sbyte Int8 ) return Int8 ;
|
||||
else if (MsgPack.Object is byte UInt8 ) return UInt8 ;
|
||||
else if (MsgPack.Object is short Int16) return Int16;
|
||||
else if (MsgPack.Object is ushort UInt16) return ( short) UInt16;
|
||||
return null;
|
||||
}
|
||||
public ushort? ReadNUInt16(string Name)
|
||||
{
|
||||
if (Element(Name, out MsgPack MsgPack))
|
||||
if (MsgPack.Object is sbyte Int8 ) return (ushort) Int8 ;
|
||||
else if (MsgPack.Object is byte UInt8 ) return UInt8 ;
|
||||
else if (MsgPack.Object is short Int16) return (ushort) Int16;
|
||||
else if (MsgPack.Object is ushort UInt16) return UInt16;
|
||||
return null;
|
||||
}
|
||||
public int? ReadNInt32(string Name)
|
||||
{
|
||||
if (Element(Name, out MsgPack MsgPack))
|
||||
if (MsgPack.Object is sbyte Int8 ) return Int8 ;
|
||||
else if (MsgPack.Object is byte UInt8 ) return UInt8 ;
|
||||
else if (MsgPack.Object is short Int16) return Int16;
|
||||
else if (MsgPack.Object is ushort UInt16) return UInt16;
|
||||
else if (MsgPack.Object is int Int32) return Int32;
|
||||
else if (MsgPack.Object is uint UInt32) return ( int) UInt32;
|
||||
return null;
|
||||
}
|
||||
public uint? ReadNUInt32(string Name)
|
||||
{
|
||||
if (Element(Name, out MsgPack MsgPack))
|
||||
if (MsgPack.Object is sbyte Int8 ) return ( uint) Int8 ;
|
||||
else if (MsgPack.Object is byte UInt8 ) return UInt8 ;
|
||||
else if (MsgPack.Object is short Int16) return ( uint) Int16;
|
||||
else if (MsgPack.Object is ushort UInt16) return UInt16;
|
||||
else if (MsgPack.Object is int Int32) return ( uint) Int32;
|
||||
else if (MsgPack.Object is uint UInt32) return UInt32;
|
||||
return null;
|
||||
}
|
||||
public long? ReadNInt64(string Name)
|
||||
{
|
||||
if (Element(Name, out MsgPack MsgPack))
|
||||
if (MsgPack.Object is sbyte Int8 ) return Int8 ;
|
||||
else if (MsgPack.Object is byte UInt8 ) return UInt8 ;
|
||||
else if (MsgPack.Object is short Int16) return Int16;
|
||||
else if (MsgPack.Object is ushort UInt16) return UInt16;
|
||||
else if (MsgPack.Object is int Int32) return Int32;
|
||||
else if (MsgPack.Object is uint UInt32) return UInt32;
|
||||
else if (MsgPack.Object is long Int64) return Int64;
|
||||
else if (MsgPack.Object is ulong UInt64) return ( long) UInt64;
|
||||
return null;
|
||||
}
|
||||
public ulong? ReadNUInt64(string Name)
|
||||
{
|
||||
if (Element(Name, out MsgPack MsgPack))
|
||||
if (MsgPack.Object is sbyte Int8 ) return ( ulong) Int8 ;
|
||||
else if (MsgPack.Object is byte UInt8 ) return UInt8 ;
|
||||
else if (MsgPack.Object is short Int16) return ( ulong) Int16;
|
||||
else if (MsgPack.Object is ushort UInt16) return UInt16;
|
||||
else if (MsgPack.Object is int Int32) return ( ulong) Int32;
|
||||
else if (MsgPack.Object is uint UInt32) return UInt32;
|
||||
else if (MsgPack.Object is long Int64) return ( ulong) Int64;
|
||||
else if (MsgPack.Object is ulong UInt64) return UInt64;
|
||||
return null;
|
||||
}
|
||||
public float? ReadNSingle(string Name)
|
||||
{
|
||||
if (Element(Name, out MsgPack MsgPack))
|
||||
if (MsgPack.Object is sbyte Int8 ) return Int8 ;
|
||||
else if (MsgPack.Object is byte UInt8 ) return UInt8 ;
|
||||
else if (MsgPack.Object is short Int16) return Int16;
|
||||
else if (MsgPack.Object is ushort UInt16) return UInt16;
|
||||
else if (MsgPack.Object is int Int32) return Int32;
|
||||
else if (MsgPack.Object is uint UInt32) return UInt32;
|
||||
else if (MsgPack.Object is long Int64) return Int64;
|
||||
else if (MsgPack.Object is float Float32) return Float32;
|
||||
else if (MsgPack.Object is double Float64) return ( float)Float64;
|
||||
return null;
|
||||
}
|
||||
public double? ReadNDouble(string Name)
|
||||
{
|
||||
if (Element(Name, out MsgPack MsgPack))
|
||||
if (MsgPack.Object is sbyte Int8 ) return Int8 ;
|
||||
else if (MsgPack.Object is byte UInt8 ) return UInt8 ;
|
||||
else if (MsgPack.Object is short Int16) return Int16;
|
||||
else if (MsgPack.Object is ushort UInt16) return UInt16;
|
||||
else if (MsgPack.Object is int Int32) return Int32;
|
||||
else if (MsgPack.Object is uint UInt32) return UInt32;
|
||||
else if (MsgPack.Object is long Int64) return Int64;
|
||||
else if (MsgPack.Object is float Float32) return Float32;
|
||||
else if (MsgPack.Object is double Float64) return Float64;
|
||||
return null;
|
||||
}
|
||||
public string ReadString(string Name)
|
||||
{
|
||||
if (Element(Name, out MsgPack MsgPack))
|
||||
if (MsgPack.Object is string String) return String;
|
||||
return null;
|
||||
}
|
||||
|
||||
public bool ReadBoolean() => ReadNBoolean().GetValueOrDefault();
|
||||
public sbyte ReadInt8() => ReadNInt8().GetValueOrDefault();
|
||||
public byte ReadUInt8() => ReadNUInt8().GetValueOrDefault();
|
||||
public short ReadInt16() => ReadNInt16().GetValueOrDefault();
|
||||
public ushort ReadUInt16() => ReadNUInt16().GetValueOrDefault();
|
||||
public int ReadInt32() => ReadNInt32().GetValueOrDefault();
|
||||
public uint ReadUInt32() => ReadNUInt32().GetValueOrDefault();
|
||||
public long ReadInt64() => ReadNInt64().GetValueOrDefault();
|
||||
public ulong ReadUInt64() => ReadNUInt64().GetValueOrDefault();
|
||||
public float ReadSingle() => ReadNSingle().GetValueOrDefault();
|
||||
public double ReadDouble() => ReadNDouble().GetValueOrDefault();
|
||||
|
||||
public bool? ReadNBoolean()
|
||||
{ if (Object is bool Boolean) return Boolean; return null; }
|
||||
public sbyte? ReadNInt8()
|
||||
{ if (Object is sbyte Int8 ) return Int8 ;
|
||||
else if (Object is byte UInt8 ) return ( sbyte) UInt8 ; return null; }
|
||||
public byte? ReadNUInt8()
|
||||
{ if (Object is sbyte Int8 ) return ( byte) Int8 ;
|
||||
else if (Object is byte UInt8 ) return UInt8 ; return null; }
|
||||
public short? ReadNInt16()
|
||||
{ if (Object is sbyte Int8 ) return Int8 ;
|
||||
else if (Object is byte UInt8 ) return UInt8 ;
|
||||
else if (Object is short Int16) return Int16;
|
||||
else if (Object is ushort UInt16) return ( short) UInt16; return null; }
|
||||
public ushort? ReadNUInt16()
|
||||
{ if (Object is sbyte Int8 ) return (ushort) Int8 ;
|
||||
else if (Object is byte UInt8 ) return UInt8 ;
|
||||
else if (Object is short Int16) return (ushort) Int16;
|
||||
else if (Object is ushort UInt16) return UInt16; return null; }
|
||||
public int? ReadNInt32()
|
||||
{ if (Object is sbyte Int8 ) return Int8 ;
|
||||
else if (Object is byte UInt8 ) return UInt8 ;
|
||||
else if (Object is short Int16) return Int16;
|
||||
else if (Object is ushort UInt16) return UInt16;
|
||||
else if (Object is int Int32) return Int32;
|
||||
else if (Object is uint UInt32) return ( int) UInt32; return null; }
|
||||
public uint? ReadNUInt32()
|
||||
{ if (Object is sbyte Int8 ) return ( uint) Int8 ;
|
||||
else if (Object is byte UInt8 ) return UInt8 ;
|
||||
else if (Object is short Int16) return ( uint) Int16;
|
||||
else if (Object is ushort UInt16) return UInt16;
|
||||
else if (Object is int Int32) return ( uint) Int32;
|
||||
else if (Object is uint UInt32) return UInt32; return null; }
|
||||
public long? ReadNInt64()
|
||||
{ if (Object is sbyte Int8 ) return Int8 ;
|
||||
else if (Object is byte UInt8 ) return UInt8 ;
|
||||
else if (Object is short Int16) return Int16;
|
||||
else if (Object is ushort UInt16) return UInt16;
|
||||
else if (Object is int Int32) return Int32;
|
||||
else if (Object is uint UInt32) return UInt32;
|
||||
else if (Object is long Int64) return Int64;
|
||||
else if (Object is ulong UInt64) return ( long) UInt64; return null; }
|
||||
public ulong? ReadNUInt64()
|
||||
{ if (Object is sbyte Int8 ) return ( ulong) Int8 ;
|
||||
else if (Object is byte UInt8 ) return UInt8 ;
|
||||
else if (Object is short Int16) return ( ulong) Int16;
|
||||
else if (Object is ushort UInt16) return UInt16;
|
||||
else if (Object is int Int32) return ( ulong) Int32;
|
||||
else if (Object is uint UInt32) return UInt32;
|
||||
else if (Object is long Int64) return ( ulong) Int64;
|
||||
else if (Object is ulong UInt64) return UInt64; return null; }
|
||||
public float? ReadNSingle()
|
||||
{ if (Object is sbyte Int8 ) return Int8 ;
|
||||
else if (Object is byte UInt8 ) return UInt8 ;
|
||||
else if (Object is short Int16) return Int16;
|
||||
else if (Object is ushort UInt16) return UInt16;
|
||||
else if (Object is int Int32) return Int32;
|
||||
else if (Object is uint UInt32) return UInt32;
|
||||
else if (Object is long Int64) return Int64;
|
||||
else if (Object is float Float32) return Float32;
|
||||
else if (Object is double Float64) return ( float)Float64; return null; }
|
||||
public double? ReadNDouble()
|
||||
{ if (Object is sbyte Int8 ) return Int8 ;
|
||||
else if (Object is byte UInt8 ) return UInt8 ;
|
||||
else if (Object is short Int16) return Int16;
|
||||
else if (Object is ushort UInt16) return UInt16;
|
||||
else if (Object is int Int32) return Int32;
|
||||
else if (Object is uint UInt32) return UInt32;
|
||||
else if (Object is long Int64) return Int64;
|
||||
else if (Object is float Float32) return Float32;
|
||||
else if (Object is double Float64) return Float64; return null; }
|
||||
public string ReadString()
|
||||
{ if (Object is string String) return String; return null; }
|
||||
|
||||
public bool ElementArray(string Name, out MsgPack MsgPack) =>
|
||||
Element(Name, out MsgPack) ? MsgPack.Array != null : false;
|
||||
|
||||
public bool Element(string Name, out MsgPack MsgPack)
|
||||
{
|
||||
MsgPack = New;
|
||||
if (List.IsNull) return false;
|
||||
|
||||
for (int i = 0; i < List.Count; i++)
|
||||
if (List[i].Name == Name) { MsgPack = List[i]; return true; }
|
||||
return false;
|
||||
}
|
||||
|
||||
public bool ContainsKey(string Name)
|
||||
{
|
||||
if (List.IsNull) return false;
|
||||
|
||||
for (int i = 0; i < List.Count ; i++)
|
||||
if (List[i].Name == Name) return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
public struct Ext
|
||||
{
|
||||
public sbyte Type;
|
||||
public byte[] Data;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
namespace KKdBaseLib
|
||||
{
|
||||
public struct Pointer<T>
|
||||
{
|
||||
public int Offset;
|
||||
public T Value;
|
||||
|
||||
public override string ToString() => Extensions.ToString(Value);
|
||||
}
|
||||
|
||||
public struct CountPointer<T>
|
||||
{
|
||||
public int Count { get => Entries != null ? Entries.Length : 0;
|
||||
set => Entries = value < 0 ? null : new T[value]; }
|
||||
public int Offset;
|
||||
public T[] Entries;
|
||||
|
||||
|
||||
public T this[int index]
|
||||
{ get => Count > 0 ? Entries[index] : default;
|
||||
set { if (Count > 0) Entries[index] = value; } }
|
||||
|
||||
public override string ToString() => Count < 1 ? "No Entries" :
|
||||
Count == 1 ? Entries[0].ToString() : "Count: " + Count;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
using System.Reflection;
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
[assembly: AssemblyTitle("KKdBaseLib")]
|
||||
[assembly: AssemblyDescription("A base library")]
|
||||
[assembly: AssemblyConfiguration("")]
|
||||
[assembly: AssemblyCompany("")]
|
||||
[assembly: AssemblyProduct("KKdBaseLib")]
|
||||
[assembly: AssemblyCopyright("korenkonder © 2019")]
|
||||
[assembly: AssemblyTrademark("")]
|
||||
[assembly: AssemblyCulture("")]
|
||||
[assembly: ComVisible(false)]
|
||||
[assembly: Guid("437F63F1-8C23-429E-AB14-38B85C9EDB16")]
|
||||
[assembly: AssemblyVersion("0.4.7.4")]
|
||||
[assembly: AssemblyFileVersion("0.4.7.4")]
|
||||
@@ -0,0 +1,16 @@
|
||||
using System.Text;
|
||||
|
||||
namespace KKdBaseLib
|
||||
{
|
||||
public static class Text
|
||||
{
|
||||
public readonly static Encoding ShiftJIS = Encoding.GetEncoding(932);
|
||||
|
||||
public static string ToASCII(this byte[] Array) => Encoding.ASCII.GetString(Array ?? new byte[0]);
|
||||
public static string ToUTF8 (this byte[] Array) => Encoding.UTF8 .GetString(Array ?? new byte[0]);
|
||||
public static byte[] ToASCII(this string Data ) => Encoding.ASCII.GetBytes (Data ?? "" );
|
||||
public static byte[] ToUTF8 (this string Data ) => Encoding.UTF8 .GetBytes (Data ?? "" );
|
||||
public static byte[] ToASCII(this char[] Data ) => Encoding.ASCII.GetBytes (Data ?? new char[0]);
|
||||
public static byte[] ToUTF8 (this char[] Data ) => Encoding.UTF8 .GetBytes (Data ?? new char[0]);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
namespace KKdBaseLib
|
||||
{
|
||||
public struct Vector2<T>
|
||||
{
|
||||
public T X;
|
||||
public T Y;
|
||||
|
||||
public Vector2(T X, T Y)
|
||||
{ this.X = X; this.Y = Y; }
|
||||
|
||||
public bool NotNull => X != null && Y != null;
|
||||
|
||||
public override string ToString() => "X: " + X + "; Y: " + Y;
|
||||
}
|
||||
|
||||
public struct Vector3<T>
|
||||
{
|
||||
public T X;
|
||||
public T Y;
|
||||
public T Z;
|
||||
|
||||
public Vector3(T X, T Y, T Z)
|
||||
{ this.X = X; this.Y = Y; this.Z = Z; }
|
||||
|
||||
public bool NotNull => X != null && Y != null && Z != null;
|
||||
|
||||
public override string ToString() => "X: " + X + "; Y: " + Y + "; Z: " + Z;
|
||||
}
|
||||
|
||||
public struct Vector4<T>
|
||||
{
|
||||
public T X;
|
||||
public T Y;
|
||||
public T Z;
|
||||
public T W;
|
||||
|
||||
public Vector4(T X, T Y, T Z, T W)
|
||||
{ this.X = X; this.Y = Y; this.Z = Z; this.W = W; }
|
||||
|
||||
public bool NotNull => X != null && Y != null && Z != null && W != null;
|
||||
|
||||
public override string ToString() => "X: " + X + "; Y: " + Y + "; Z: " + Z + "; W: " + W;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,77 @@
|
||||
namespace KKdBaseLib
|
||||
{
|
||||
public struct Vector3
|
||||
{
|
||||
public double X;
|
||||
public double Y;
|
||||
public double Z;
|
||||
|
||||
public Vector3(double X, double Y, double Z)
|
||||
{ this.X = X; this.Y = Y; this.Z = Z; }
|
||||
|
||||
public double Length => (X * X + Y * Y + Z * Z).Sqrt();
|
||||
public Vector3 Normalized => this = Length == 0 ? new Vector3() : this / Length;
|
||||
|
||||
public static Vector3 operator +(Vector3 left, Vector3 right)
|
||||
{ left.X += right.X; left.Y += right.Y; left.Z += right.Z; return left; }
|
||||
public static Vector3 operator -(Vector3 left, Vector3 right)
|
||||
{ left.X -= right.X; left.Y -= right.Y; left.Z -= right.Z; return left; }
|
||||
public static Vector3 operator -(Vector3 vec)
|
||||
{ vec.X = -vec.X; vec.Y = -vec.Y; vec.Z = -vec.Z; return vec; }
|
||||
public static Vector3 operator *(Vector3 vec, double scale)
|
||||
{ vec.X *= scale ; vec.Y *= scale ; vec.Z *= scale ; return vec; }
|
||||
public static Vector3 operator *( double scale, Vector3 vec)
|
||||
{ vec.X *= scale ; vec.Y *= scale ; vec.Z *= scale ; return vec; }
|
||||
public static Vector3 operator *(Vector3 vec, Vector3 scale)
|
||||
{ vec.X *= scale.X; vec.Y *= scale.Y; vec.Z *= scale.Z; return vec; }
|
||||
public static Vector3 operator /(Vector3 vec, double scale)
|
||||
{ vec.X /= scale ; vec.Y /= scale ; vec.Z /= scale ; return vec; }
|
||||
public static Vector3 operator /(Vector3 vec, Vector3 scale)
|
||||
{ vec.X /= scale.X; vec.Y /= scale.Y; vec.Z /= scale.Z; return vec; }
|
||||
public static bool operator ==(Vector3 A, Vector3 B) => A.Equals(B);
|
||||
public static bool operator !=(Vector3 A, Vector3 B) => !A.Equals(B);
|
||||
|
||||
public static double Distance (Vector3 left, Vector3 right) =>
|
||||
(right.X - left.X) * (right.X - left.X) + (right.Y - left.Y) *
|
||||
(right.Y - left.Y) + (right.Z - left.Z) * (right.Z - left.Z).Sqrt();
|
||||
public static double DistanceSquared(Vector3 left, Vector3 right) =>
|
||||
(right.X - left.X) * (right.X - left.X) + (right.Y - left.Y) *
|
||||
(right.Y - left.Y) + (right.Z - left.Z) * (right.Z - left.Z);
|
||||
public static double Dot (Vector3 left, Vector3 right) =>
|
||||
(left.X * right.X) + (left.Y * right.Y) + (left.Z * right.Z);
|
||||
public static Vector3 Cross(Vector3 left, Vector3 right) =>
|
||||
new Vector3 { X = (left.Y * right.Z) - (left.Z * right.Y),
|
||||
Y = (left.Z * right.X) - (left.X * right.Z),
|
||||
Z = (left.X * right.Y) - (left.Y * right.X), };
|
||||
public static Vector3 Lerp (Vector3 a, Vector3 b, double blend) =>
|
||||
new Vector3 { X = blend * (b.X - a.X) + a.X,
|
||||
Y = blend * (b.Y - a.Y) + a.Y,
|
||||
Z = blend * (b.Z - a.Z) + a.Z };
|
||||
public static Vector3 Lerp (Vector3 a, Vector3 b, Vector3 blend) =>
|
||||
new Vector3 { X = blend.X * (b.X - a.X) + a.X,
|
||||
Y = blend.Y * (b.Y - a.Y) + a.Y,
|
||||
Z = blend.Z * (b.Z - a.Z) + a.Z };
|
||||
public Vector3 Round( ) =>
|
||||
new Vector3 { X = X.Round( ), Y = Y.Round( ), Z = Z.Round( ) };
|
||||
public Vector3 Round(int d) =>
|
||||
new Vector3 { X = X.Round(d), Y = Y.Round(d), Z = Z.Round(d) };
|
||||
|
||||
public override int GetHashCode()
|
||||
{
|
||||
unchecked
|
||||
{
|
||||
int hashCode = X.GetHashCode();
|
||||
hashCode = (hashCode * 397) ^ Y.GetHashCode();
|
||||
hashCode = (hashCode * 397) ^ Z.GetHashCode();
|
||||
return hashCode;
|
||||
}
|
||||
}
|
||||
public override bool Equals(object obj) =>
|
||||
obj is Vector3 vec ? Equals(vec) : false;
|
||||
public bool Equals(Vector3 other) =>
|
||||
X == other.X && Y == other.Y && Z == other.Z;
|
||||
|
||||
public override string ToString() => $"{X},{Y},{Z}";
|
||||
public string ToString(int d) => $"{X.Round(d)},{Y.Round(d)},{Z.Round(d)}";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,77 @@
|
||||
namespace KKdBaseLib
|
||||
{
|
||||
public struct Vector4
|
||||
{
|
||||
public double X;
|
||||
public double Y;
|
||||
public double Z;
|
||||
public double W;
|
||||
|
||||
public Vector4(double X, double Y, double Z, double W)
|
||||
{ this.X = X; this.Y = Y; this.Z = Z; this.W = W; }
|
||||
|
||||
public double Length => (X * X + Y * Y + Z * Z + W * W).Sqrt();
|
||||
public Vector4 Normalized => this = Length == 0 ? new Vector4() : this / Length;
|
||||
|
||||
public static Vector4 operator +(Vector4 left, Vector4 right)
|
||||
{ left.X += right.X; left.Y += right.Y; left.Z += right.Z; left.W += right.W; return left; }
|
||||
public static Vector4 operator -(Vector4 left, Vector4 right)
|
||||
{ left.X -= right.X; left.Y -= right.Y; left.Z -= right.Z; left.W -= right.W; return left; }
|
||||
public static Vector4 operator -(Vector4 vec)
|
||||
{ vec.X = -vec.X; vec.Y = -vec.Y; vec.Z = -vec.Z; vec.W = -vec.W; return vec; }
|
||||
public static Vector4 operator *(Vector4 vec, double scale)
|
||||
{ vec.X *= scale ; vec.Y *= scale ; vec.Z *= scale ; vec.W *= scale ; return vec; }
|
||||
public static Vector4 operator *( double scale, Vector4 vec)
|
||||
{ vec.X *= scale ; vec.Y *= scale ; vec.Z *= scale ; vec.W *= scale ; return vec; }
|
||||
public static Vector4 operator *(Vector4 vec, Vector4 scale)
|
||||
{ vec.X *= scale.X; vec.Y *= scale.Y; vec.Z *= scale.Z; vec.W *= scale.W; return vec; }
|
||||
public static Vector4 operator /(Vector4 vec, double scale)
|
||||
{ vec.X /= scale ; vec.Y /= scale ; vec.Z /= scale ; vec.W /= scale ; return vec; }
|
||||
public static Vector4 operator /(Vector4 vec, Vector4 scale)
|
||||
{ vec.X /= scale.X; vec.Y /= scale.Y; vec.Z /= scale.Z; vec.W /= scale.W; return vec; }
|
||||
public static bool operator ==(Vector4 A, Vector4 B) => A.Equals(B);
|
||||
public static bool operator !=(Vector4 A, Vector4 B) => !A.Equals(B);
|
||||
|
||||
public static double Distance (Vector4 left, Vector4 right) =>
|
||||
((right.X - left.X) * (right.X - left.X) + (right.Y - left.Y) * (right.Y - left.Y) +
|
||||
(right.Z - left.Z) * (right.Z - left.Z) + (right.W - left.W) * (right.W - left.W)).Sqrt();
|
||||
public static double DistanceSquared(Vector4 left, Vector4 right) =>
|
||||
(right.X - left.X) * (right.X - left.X) + (right.Y - left.Y) * (right.Y - left.Y) +
|
||||
(right.Z - left.Z) * (right.Z - left.Z) + (right.W - left.W) * (right.W - left.W);
|
||||
public static double Dot (Vector4 left, Vector4 right) =>
|
||||
(left.X * right.X) + (left.Y * right.Y) + (left.Z * right.Z) + (left.W * right.W);
|
||||
public static Vector4 Lerp (Vector4 a, Vector4 b, double blend) =>
|
||||
new Vector4 { X = blend * (b.X - a.X) + a.X,
|
||||
Y = blend * (b.Y - a.Y) + a.Y,
|
||||
Z = blend * (b.Z - a.Z) + a.Z,
|
||||
W = blend * (b.W - a.W) + a.W };
|
||||
public static Vector4 Lerp (Vector4 a, Vector4 b, Vector4 blend) =>
|
||||
new Vector4 { X = blend.X * (b.X - a.X) + a.X,
|
||||
Y = blend.Y * (b.Y - a.Y) + a.Y,
|
||||
Z = blend.Z * (b.Z - a.Z) + a.Z,
|
||||
W = blend.W * (b.W - a.W) + a.W };
|
||||
public Vector4 Round( ) =>
|
||||
new Vector4 { X = X.Round( ), Y = Y.Round( ), Z = Z.Round( ), W = W.Round( ) };
|
||||
public Vector4 Round(int d) =>
|
||||
new Vector4 { X = X.Round(d), Y = Y.Round(d), Z = Z.Round(d), W = W.Round(d) };
|
||||
|
||||
public override int GetHashCode()
|
||||
{
|
||||
unchecked
|
||||
{
|
||||
int hashCode = X.GetHashCode();
|
||||
hashCode = (hashCode * 397) ^ Y.GetHashCode();
|
||||
hashCode = (hashCode * 397) ^ Z.GetHashCode();
|
||||
hashCode = (hashCode * 397) ^ W.GetHashCode();
|
||||
return hashCode;
|
||||
}
|
||||
}
|
||||
public override bool Equals(object obj) =>
|
||||
obj is Vector4 vec ? Equals(vec) : false;
|
||||
public bool Equals(Vector4 other) =>
|
||||
X == other.X && Y == other.Y && Z == other.Z && W == other.W;
|
||||
|
||||
public override string ToString() => $"{X},{Y},{Z},{W}";
|
||||
public string ToString(int d) => $"{X.Round(d)},{Y.Round(d)},{Z.Round(d)},{W.Round(d)}";
|
||||
}
|
||||
}
|
||||
+2620
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -1,421 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using KKdMainLib.IO;
|
||||
using KKdMainLib.MessagePack;
|
||||
|
||||
namespace KKdMainLib.A3DA
|
||||
{
|
||||
public static class A3DAExt
|
||||
{
|
||||
private const string d = ".";
|
||||
private const string BO = "bin_offset";
|
||||
private const string MTBO = "model_transform" + d + BO;
|
||||
|
||||
private static string value;
|
||||
private static string[] dataArray;
|
||||
private static int SOi;
|
||||
private static int[] SO;
|
||||
|
||||
public static ModelTransform ReadMT(this Dictionary<string, object> Dict, string Temp)
|
||||
{
|
||||
ModelTransform MT = new ModelTransform();
|
||||
Dict.FindValue(out MT.BinOffset, Temp + MTBO);
|
||||
|
||||
MT.Rot = Dict.ReadVec3(Temp + "rot" + d);
|
||||
MT.Scale = Dict.ReadVec3(Temp + "scale" + d);
|
||||
MT.Trans = Dict.ReadVec3(Temp + "trans" + d);
|
||||
MT.Visibility = Dict.ReadKey (Temp + "visibility" + d);
|
||||
return MT;
|
||||
}
|
||||
|
||||
public static RGBAKey ReadRGBAKey(this Dictionary<string, object> Dict, string Temp) =>
|
||||
new RGBAKey { A = Dict.ReadKey(Temp + "a" + d), B = Dict.ReadKey(Temp + "b" + d),
|
||||
G = Dict.ReadKey(Temp + "g" + d), R = Dict.ReadKey(Temp + "r" + d) };
|
||||
|
||||
public static Vector3<Key> ReadVec3(this Dictionary<string, object> Dict, string Temp) =>
|
||||
new Vector3<Key> { X = Dict.ReadKey(Temp + "x" + d), Y =
|
||||
Dict.ReadKey(Temp + "y" + d), Z = Dict.ReadKey(Temp + "z" + d) };
|
||||
|
||||
public static KeyUV ReadKeyUV(this Dictionary<string, object> Dict, string Temp) =>
|
||||
new KeyUV { U = Dict.ReadKey(Temp + "U" + d), V = Dict.ReadKey(Temp + "V" + d) };
|
||||
|
||||
public static Key ReadKey(this Dictionary<string, object> Dict, string Temp)
|
||||
{
|
||||
Key Key = new Key();
|
||||
Dict.FindValue(out Key.BinOffset, Temp + BO );
|
||||
Dict.FindValue(out Key.Type , Temp + "type");
|
||||
|
||||
if (Key.BinOffset == null && Key.Type == null) return null;
|
||||
if (Key.Type == null) return Key;
|
||||
if (Key.Type == 0x0000) return Key;
|
||||
|
||||
if (Key.Type == 0x0001) { Dict.FindValue(out Key.Value, Temp + "value"); return Key; }
|
||||
|
||||
int i = 0, i0 = 0;
|
||||
byte i1 = 0;
|
||||
Dict.FindValue(out Key.EPTypePost, Temp + "ep_type_post");
|
||||
Dict.FindValue(out Key.EPTypePre , Temp + "ep_type_pre" );
|
||||
Dict.FindValue(out Key.Length , Temp + "key.length" );
|
||||
Dict.FindValue(out Key.Max , Temp + "max" );
|
||||
if (Dict.StartsWith(Temp + "raw_data"))
|
||||
Dict.FindValue(out Key.RawData.KeyType, Temp + "raw_data_key_type");
|
||||
|
||||
if (Key.Length != null)
|
||||
{
|
||||
Key.Trans = new Key.Transform[(int)Key.Length];
|
||||
for (i0 = 0; i0 < Key.Length; i0++)
|
||||
if (Dict.FindValue(out value, Temp + "key" + d + i0 + d + "data"))
|
||||
{
|
||||
Key.Trans[i0] = new Key.Transform();
|
||||
dataArray = value.Replace("(", "").Replace(")", "").Split(',');
|
||||
Key.Trans[i0].Type = dataArray.Length - 1;
|
||||
Key.Trans[i0].Frame = dataArray[0].ToDouble();
|
||||
Key.Trans[i0].Value = new double[Key.Trans[i0].Type];
|
||||
for (i1 = 1; i1 < dataArray.Length; i1++)
|
||||
Key.Trans[i0].Value[i1 - 1] = dataArray[i1].ToDouble();
|
||||
}
|
||||
}
|
||||
else if (Key.RawData.KeyType != null)
|
||||
{
|
||||
Key.RawData = new Key.RawD();
|
||||
Dict.FindValue(out Key.RawData.ValueType, Temp + "raw_data.value_type");
|
||||
if (Dict.FindValue(out value, Temp + "raw_data.value_list"))
|
||||
Key.RawData.ValueList = value.Split(',');
|
||||
Dict.FindValue(out Key.RawData.ValueListSize, Temp + "raw_data.value_list_size");
|
||||
value = "";
|
||||
|
||||
int DataSize = (int)Key.RawData.KeyType + 1;
|
||||
Key.Length = Key.RawData.ValueListSize / DataSize;
|
||||
Key.Trans = new Key.Transform[(int)Key.Length];
|
||||
for (i = 0; i < Key.Length; i++)
|
||||
{
|
||||
Key.Trans[i].Type = (int)Key.RawData.KeyType;
|
||||
Key.Trans[i].Frame = Key.RawData.ValueList[i * DataSize + 0].ToDouble();
|
||||
Key.Trans[i].Value = new double[Key.Trans[i0].Type];
|
||||
for (i1 = 1; i1 < Key.Trans[i].Type; i1++)
|
||||
Key.Trans[i].Value[i1 - 1] = Key.RawData.ValueList[i * DataSize + i1].ToDouble();
|
||||
}
|
||||
Key.RawData.ValueList = null;
|
||||
}
|
||||
return Key;
|
||||
}
|
||||
|
||||
public static void Write(this Stream IO, ModelTransform MT,
|
||||
string Temp, bool A3DC, bool IsX = false, byte Flags = 0b11111)
|
||||
{
|
||||
if (A3DC && !MT.Writed && (Flags & 0b10000) == 0b10000)
|
||||
{ IO.Write(Temp + MTBO + "=", MT.BinOffset); MT.Writed = true; }
|
||||
|
||||
if (A3DC) return;
|
||||
|
||||
if ((Flags & 0b01000) == 0b01000) IO.Write(MT.Rot , Temp + "rot" + d, A3DC);
|
||||
if ((Flags & 0b00100) == 0b00100) IO.Write(MT.Scale , Temp + "scale" + d, A3DC);
|
||||
if ((Flags & 0b00010) == 0b00010) IO.Write(MT.Trans , Temp + "trans" + d, A3DC);
|
||||
if ((Flags & 0b00001) == 0b00001) IO.Write(MT.Visibility, Temp + "visibility" + d, A3DC);
|
||||
}
|
||||
|
||||
public static void Write(this Stream IO, RGBAKey RGBA, string Temp, string Data, bool A3DC = false)
|
||||
{
|
||||
if (RGBA.R == null && RGBA.B == null && RGBA.G == null && RGBA.A == null) return;
|
||||
IO.Write(Temp + Data + "=", "true");
|
||||
IO.Write(RGBA.A, Temp + Data + d + "a" + d, A3DC); IO.Write(RGBA.B, Temp + Data + d + "b" + d, A3DC);
|
||||
IO.Write(RGBA.G, Temp + Data + d + "g" + d, A3DC); IO.Write(RGBA.R, Temp + Data + d + "r" + d, A3DC);
|
||||
}
|
||||
|
||||
public static void Write(this Stream IO, Vector3<Key> Key, string Temp, bool A3DC = false)
|
||||
{ IO.Write(Key.X, Temp + "x" + d, A3DC); IO.Write(Key.Y,
|
||||
Temp + "y" + d, A3DC); IO.Write(Key.Z, Temp + "z" + d, A3DC); }
|
||||
|
||||
public static void Write(this Stream IO, KeyUV UV, string Temp, string Data, bool A3DC = false)
|
||||
{ IO.Write(UV.U, Temp, Data + "U", A3DC); IO.Write(UV.V, Temp, Data + "V", A3DC); }
|
||||
|
||||
public static void Write(this Stream IO, Key Key, string Temp, string Data, bool A3DC = false)
|
||||
{ if (Key != null) { IO.Write(Temp + Data + "=", "true"); IO.Write(Key, Temp + Data + d, A3DC); } }
|
||||
|
||||
public static void Write(this Stream IO, Key Key, string Temp, bool A3DC = false)
|
||||
{
|
||||
if (Key == null) return;
|
||||
|
||||
if (A3DC) { IO.Write(Temp + BO + "=", Key.BinOffset); return; }
|
||||
|
||||
int i = 0;
|
||||
if (Key.Trans != null)
|
||||
if (Key.Trans.Length == 0)
|
||||
{
|
||||
IO.Write(Temp + "type=", Key.Type);
|
||||
if (Key.Type > 0) IO.Write(Temp + "value=", Key.Value);
|
||||
return;
|
||||
}
|
||||
|
||||
if (Key.EPTypePost != null) IO.Write(Temp + "ep_type_post=", Key.EPTypePost);
|
||||
if (Key.EPTypePre != null) IO.Write(Temp + "ep_type_pre=" , Key.EPTypePre );
|
||||
if (Key.RawData == null && Key.Trans != null)
|
||||
{
|
||||
SO = Key.Trans.Length.SortWriter();
|
||||
for (i = 0; i < Key.Trans.Length; i++)
|
||||
{
|
||||
SOi = SO[i];
|
||||
IO.Write(Temp + "key" + d + SOi + d + "data=", Key.Trans[SOi].ToString());
|
||||
IO.Write(Temp + "key" + d + SOi + d + "type=", Key.Trans[SOi].Type );
|
||||
}
|
||||
IO.Write(Temp + "key.length=", Key.Length);
|
||||
if (Key.Max != null) IO.Write(Temp + "max=", Key.Max);
|
||||
}
|
||||
else if (Key.Trans != null)
|
||||
{
|
||||
if (Key.Max != null) IO.Write(Temp + "max=", Key.Max);
|
||||
for (i = 0; i < Key.Trans.Length; i++)
|
||||
{
|
||||
if (Key.RawData.KeyType < Key.Trans[i].Type || Key.RawData.KeyType == null)
|
||||
Key.RawData.KeyType = Key.Trans[i].Type;
|
||||
if (Key.RawData.KeyType == 3) break;
|
||||
}
|
||||
Key.RawData.ValueListSize = Key.Trans.Length * (Key.RawData.KeyType + 1);
|
||||
IO.Write(Temp + "raw_data.value_list=");
|
||||
for (i = 0; i < Key.Trans.Length; i++)
|
||||
IO.Write(Key.Trans[i].ToString(false));
|
||||
IO.Position = IO.Position - 1;
|
||||
IO.Write('\n');
|
||||
IO.Write(Temp + "raw_data.value_list_size=", Key.RawData.ValueListSize);
|
||||
IO.Write(Temp + "raw_data.value_type=" , Key.RawData.ValueType );
|
||||
IO.Write(Temp + "raw_data_key_type=" , Key.RawData. KeyType );
|
||||
}
|
||||
IO.Write(Temp + "type=", Key.Type & 0xFF);
|
||||
if (Key.RawData == null && Key.Trans == null && Key.Value != null)
|
||||
if (Key.Value != 0) IO.Write(Temp + "value=", Key.Value);
|
||||
}
|
||||
|
||||
public static void ReadMT(this Stream IO, ref ModelTransform MT, int C_F16)
|
||||
{
|
||||
if (MT.BinOffset == null) return;
|
||||
|
||||
IO.Position = IO.Offset + (int)MT.BinOffset;
|
||||
|
||||
IO.ReadOffset(out MT.Scale);
|
||||
IO.ReadOffset(out MT.Rot );
|
||||
IO.ReadOffset(out MT.Trans);
|
||||
MT.Visibility = new Key { BinOffset = IO.ReadInt32() };
|
||||
|
||||
IO.ReadVec3(ref MT.Scale , C_F16);
|
||||
IO.ReadVec3(ref MT.Rot , C_F16, true);
|
||||
IO.ReadVec3(ref MT.Trans , C_F16);
|
||||
IO.ReadKey (ref MT.Visibility, C_F16);
|
||||
}
|
||||
|
||||
public static void ReadRGBAKey(this Stream IO, ref RGBAKey RGBA, int C_F16)
|
||||
{ IO.ReadKey(ref RGBA.R, C_F16); IO.ReadKey(ref RGBA.G, C_F16);
|
||||
IO.ReadKey(ref RGBA.B, C_F16); IO.ReadKey(ref RGBA.A, C_F16); }
|
||||
|
||||
public static void ReadVec3(this Stream IO, ref Vector3<Key> Key, int C_F16, bool F16 = false)
|
||||
{ IO.ReadKey(ref Key.X, C_F16, F16); IO.ReadKey(ref Key.Y,
|
||||
C_F16, F16); IO.ReadKey(ref Key.Z, C_F16, F16); }
|
||||
|
||||
public static void ReadKeyUV(this Stream IO, ref KeyUV UV, int C_F16)
|
||||
{ IO.ReadKey(ref UV.U, C_F16); IO.ReadKey(ref UV.V, C_F16); }
|
||||
|
||||
public static void ReadKey(this Stream IO, ref Key Key, int C_F16, bool F16 = false)
|
||||
{
|
||||
if (Key == null) return;
|
||||
if (Key.BinOffset == null || Key.BinOffset < 0) return;
|
||||
|
||||
IO.Position = IO.Offset + (int)Key.BinOffset;
|
||||
Key.Type = IO.ReadInt32();
|
||||
|
||||
Key.Value = IO.ReadSingle();
|
||||
if (Key.Type == 0x0000 || Key.Type == 0x0001) return;
|
||||
|
||||
Key.Max = IO.ReadSingle();
|
||||
Key.Length = IO.ReadInt32 ();
|
||||
Key.Trans = new Key.Transform[(int)Key.Length];
|
||||
int Ke = (int)Key.Length;
|
||||
for (int i = 0; i < Key.Length; i++)
|
||||
{
|
||||
Key.Trans[i] = new Key.Transform { Type = 3, Value = new double[3] };
|
||||
if (F16 && C_F16 > 0)
|
||||
{ Key.Trans[i].Frame = IO.ReadUInt16(); Key.Trans[i].Value[0] = (double)IO.ReadHalf (); }
|
||||
else
|
||||
{ Key.Trans[i].Frame = IO.ReadSingle(); Key.Trans[i].Value[0] = IO.ReadSingle(); }
|
||||
|
||||
if (F16 && C_F16 == 2)
|
||||
{ Key.Trans[i].Value[1] = (double)IO.ReadHalf ();
|
||||
Key.Trans[i].Value[2] = (double)IO.ReadHalf (); }
|
||||
else
|
||||
{ Key.Trans[i].Value[1] = IO.ReadSingle();
|
||||
Key.Trans[i].Value[2] = IO.ReadSingle(); }
|
||||
}
|
||||
}
|
||||
|
||||
public static void ReadOffset(this Stream IO, out Vector3<Key> Key)
|
||||
{ Key = new Vector3<Key> { X = new Key { BinOffset = IO.ReadInt32() },
|
||||
Y = new Key { BinOffset = IO.ReadInt32() },
|
||||
Z = new Key { BinOffset = IO.ReadInt32() }, }; }
|
||||
|
||||
public static void WriteOffset(this Stream IO, ref ModelTransform MT, bool ReturnToOffset)
|
||||
{
|
||||
if (ReturnToOffset)
|
||||
{
|
||||
IO.Position = (int)MT.BinOffset;
|
||||
IO.WriteOffset(MT.Scale);
|
||||
IO.WriteOffset(MT.Rot );
|
||||
IO.WriteOffset(MT.Trans);
|
||||
IO.Write(MT.Visibility.BinOffset);
|
||||
}
|
||||
else
|
||||
{
|
||||
MT.BinOffset = IO.Position;
|
||||
IO.Position += 0x30;
|
||||
IO.Length += 0x30;
|
||||
}
|
||||
}
|
||||
|
||||
public static void WriteOffset(this Stream IO, Vector3<Key> Key)
|
||||
{
|
||||
IO.Write(Key.X.BinOffset);
|
||||
IO.Write(Key.Y.BinOffset);
|
||||
IO.Write(Key.Z.BinOffset);
|
||||
}
|
||||
|
||||
public static ModelTransform ReadMT(this MsgPack k, string name)
|
||||
{ if (k.Element(name, out MsgPack Name)) return Name.ReadMT(); return new ModelTransform(); }
|
||||
|
||||
public static ModelTransform ReadMT(this MsgPack k) =>
|
||||
new ModelTransform { Rot = k.ReadVec3("Rot" ), Scale = k.ReadVec3("Scale" ),
|
||||
Trans = k.ReadVec3("Trans"), Visibility = k.ReadKey ("Visibility") };
|
||||
|
||||
public static RGBAKey ReadRGBAKey(this MsgPack k, string name)
|
||||
{ if (k.Element(name, out MsgPack Name)) return Name.ReadRGBAKey(); return new RGBAKey(); }
|
||||
|
||||
public static RGBAKey ReadRGBAKey(this MsgPack k) =>
|
||||
new RGBAKey { R = k.ReadKey("R"), G = k.ReadKey("G"), B = k.ReadKey("B"), A = k.ReadKey("A") };
|
||||
|
||||
public static Vector3<Key> ReadVec3(this MsgPack k, string name)
|
||||
{ if (k.Element(name, out MsgPack Name)) return Name.ReadVec3(); return new Vector3<Key>(); }
|
||||
|
||||
public static Vector3<Key> ReadVec3(this MsgPack k) =>
|
||||
new Vector3<Key> { X = k.ReadKey("X"), Y = k.ReadKey("Y"), Z = k.ReadKey("Z") };
|
||||
|
||||
public static KeyUV ReadKeyUV(this MsgPack k, string name)
|
||||
{ if (k.Element(name, out MsgPack Name)) return Name.ReadKeyUV(); return new KeyUV(); }
|
||||
|
||||
public static KeyUV ReadKeyUV(this MsgPack k) =>
|
||||
new KeyUV { U = k.ReadKey("U"), V = k.ReadKey("V") };
|
||||
|
||||
public static Key ReadKey(this MsgPack k, string name)
|
||||
{ if (k.Element(name, out MsgPack Name)) return Name.ReadKey(); return null; }
|
||||
|
||||
public static Key ReadKey(this MsgPack k)
|
||||
{
|
||||
if (k == null) return null;
|
||||
|
||||
Key Key = new Key { EPTypePost = k.ReadNDouble("Post"),
|
||||
EPTypePre = k.ReadNDouble("Pre"), Max = k.ReadNDouble("M"),
|
||||
Type = k.ReadNInt32("T"), Value = k.ReadNDouble("V") };
|
||||
if (k.ReadBoolean("RD")) Key.RawData = new Key.RawD();
|
||||
if (Key.Type == 0) Key.Value = 0.0;
|
||||
|
||||
if (Key.Type < 2) return Key;
|
||||
|
||||
if (!k.Element("Trans", out MsgPack Trans, typeof(object[]))) return Key;
|
||||
|
||||
Key.Length = ((object[])Trans.Object).Length;
|
||||
Key.Trans = new Key.Transform[Key.Length.Value];
|
||||
MsgPack _Trans = new MsgPack();
|
||||
byte i1 = 0;
|
||||
for (int i = 0; i < Key.Length; i++)
|
||||
{
|
||||
Key.Trans[i] = new Key.Transform();
|
||||
if (Trans[i].GetType() != typeof(MsgPack)) continue;
|
||||
|
||||
_Trans = (MsgPack)Trans[i];
|
||||
if (_Trans.Object.GetType() != typeof(object[])) continue;
|
||||
Key.Trans[i].Type = ((object[])_Trans.Object).Length - 1;
|
||||
Key.Trans[i].Value = new double[Key.Trans[i].Type];
|
||||
|
||||
if (_Trans[0].GetType() != typeof(MsgPack)) continue;
|
||||
Key.Trans[i].Frame = ((MsgPack)_Trans[0]).ReadDouble();
|
||||
|
||||
for (i1 = 0; i1 < Key.Trans[i].Type; i1++)
|
||||
Key.Trans[i].Value[i1] = ((MsgPack)_Trans[i1 + 1]).ReadDouble();
|
||||
}
|
||||
return Key;
|
||||
}
|
||||
|
||||
public static MsgPack WriteMP(this ModelTransform MT, string name) =>
|
||||
MT.WriteMP(new MsgPack(name));
|
||||
|
||||
public static MsgPack WriteMP(this ModelTransform MT) =>
|
||||
MT.WriteMP(new MsgPack( ));
|
||||
|
||||
public static MsgPack WriteMP(this ModelTransform MT, MsgPack MTs) =>
|
||||
MTs.Add(MT.Rot .WriteMP("Rot" ))
|
||||
.Add(MT.Scale .WriteMP("Scale" ))
|
||||
.Add(MT.Trans .WriteMP("Trans" ))
|
||||
.Add(MT.Visibility.WriteMP("Visibility"));
|
||||
|
||||
public static MsgPack WriteMP(this RGBAKey RGBA, string name)
|
||||
{
|
||||
if (RGBA.R == null && RGBA.G == null && RGBA.B == null && RGBA.A == null) return MsgPack.Null;
|
||||
return new MsgPack(name).Add(RGBA.R.WriteMP("R")).Add(RGBA.G.WriteMP("G"))
|
||||
.Add(RGBA.B.WriteMP("B")).Add(RGBA.A.WriteMP("A"));
|
||||
}
|
||||
|
||||
public static MsgPack WriteMP(this Vector3<Key> Key, string name) =>
|
||||
new MsgPack(name).Add(Key.X.WriteMP("X")).Add(Key.Y.WriteMP("Y")).Add(Key.Z.WriteMP("Z"));
|
||||
|
||||
public static MsgPack WriteMP(this KeyUV UV, string name)
|
||||
{
|
||||
if (UV.U == null && UV.V == null) return MsgPack.Null;
|
||||
return new MsgPack(name).Add(UV.U.WriteMP("U")).Add(UV.V.WriteMP("V"));
|
||||
}
|
||||
|
||||
public static MsgPack WriteMP(this Key Key, string name)
|
||||
{
|
||||
if (Key == null) return MsgPack.Null;
|
||||
if (Key.Type == null) return MsgPack.Null;
|
||||
|
||||
MsgPack Keys = new MsgPack(name).Add("T", Key.Type);
|
||||
if (Key.Trans != null)
|
||||
{
|
||||
Keys.Add("Post", Key.EPTypePost).Add("Pre", Key.EPTypePre).Add("M", Key.Max);
|
||||
|
||||
if (Key.RawData != null) Keys.Add("RD", true);
|
||||
|
||||
byte i0 = 0;
|
||||
MsgPack Trans = new MsgPack("Trans", Key.Trans.Length);
|
||||
for (int i = 0; i < Key.Trans.Length; i++)
|
||||
{
|
||||
MsgPack K = new MsgPack(Key.Trans[i].Type + 1);
|
||||
K[0] = Key.Trans[i].Frame;
|
||||
for (i0 = 1; i0 < Key.Trans[i].Type + 1; i0++)
|
||||
K[i0] = Key.Trans[i].Value[i0 - 1];
|
||||
Trans[i] = K;
|
||||
}
|
||||
Keys.Add(Trans);
|
||||
}
|
||||
else if (Key.Value != 0) Keys.Add("V", Key.Value);
|
||||
return Keys;
|
||||
}
|
||||
|
||||
public static void Write(this Stream IO, string Data, ref bool? val)
|
||||
{ if (val != null) IO.Write(Data, ( bool)val ); }
|
||||
public static void Write(this Stream IO, string Data, long? val)
|
||||
{ if (val != null) IO.Write(Data, ( long)val ); }
|
||||
public static void Write(this Stream IO, string Data, ulong? val)
|
||||
{ if (val != null) IO.Write(Data, ( ulong)val ); }
|
||||
public static void Write(this Stream IO, string Data, double? val)
|
||||
{ if (val != null) IO.Write(Data, (double)val ); }
|
||||
public static void Write(this Stream IO, string Data, double? val, byte r)
|
||||
{ if (val != null) IO.Write(Data, (double)val, r); }
|
||||
public static void Write(this Stream IO, string Data, ref bool val) =>
|
||||
IO.Write(Data, Main.ToString(val));
|
||||
public static void Write(this Stream IO, string Data, long val) =>
|
||||
IO.Write(Data, val.ToString( ));
|
||||
public static void Write(this Stream IO, string Data, ulong val) =>
|
||||
IO.Write(Data, val.ToString( ));
|
||||
public static void Write(this Stream IO, string Data, double val) =>
|
||||
IO.Write(Data, val.ToString( ));
|
||||
public static void Write(this Stream IO, string Data, double val, byte r) =>
|
||||
IO.Write(Data, val.ToString(r ));
|
||||
public static void Write(this Stream IO, string Data, string val)
|
||||
{ if (val != null) IO.Write((Data + val + "\n").ToUTF8()); }
|
||||
}
|
||||
}
|
||||
+1376
-24
File diff suppressed because it is too large
Load Diff
+13
-17
@@ -1,9 +1,8 @@
|
||||
//Original: https://github.com/blueskythlikesclouds/MikuMikuLibrary/
|
||||
|
||||
using System.Collections.Generic;
|
||||
using KKdBaseLib;
|
||||
using KKdMainLib.IO;
|
||||
using KKdMainLib.MessagePack;
|
||||
using MPIO = KKdMainLib.MessagePack.IO;
|
||||
|
||||
namespace KKdMainLib.DB
|
||||
{
|
||||
@@ -191,16 +190,15 @@ namespace KKdMainLib.DB
|
||||
|
||||
public void MsgPackReader(string file, bool JSON)
|
||||
{
|
||||
MsgPack MsgPack = file.ReadMP(JSON);
|
||||
MsgPack MsgPack = file.ReadMPAllAtOnce(JSON);
|
||||
|
||||
if (MsgPack.Element("AetDB", out MsgPack AetDB, typeof(object[])))
|
||||
if (MsgPack.ElementArray("AetDB", out MsgPack AetDB))
|
||||
{
|
||||
AetSets = new AetSet[((object[])AetDB.Object).Length];
|
||||
AetSets = new AetSet[AetDB.Array.Length];
|
||||
for (int i = 0; i < AetSets.Length; i++)
|
||||
if (AetDB[i].GetType() == typeof(MsgPack))
|
||||
AetSets[i].ReadMsgPack((MsgPack)AetDB[i]);
|
||||
AetSets[i].ReadMsgPack(AetDB[i]);
|
||||
}
|
||||
MsgPack = null;
|
||||
MsgPack.Dispose();
|
||||
}
|
||||
|
||||
|
||||
@@ -209,7 +207,7 @@ namespace KKdMainLib.DB
|
||||
if (AetSets == null) return;
|
||||
if (AetSets.Length == 0) return;
|
||||
|
||||
MsgPack AetDB = new MsgPack("AetDB", AetSets.Length);
|
||||
MsgPack AetDB = new MsgPack(AetSets.Length, "AetDB");
|
||||
for (i = 0; i < AetSets.Length; i++)
|
||||
AetDB[i] = AetSets[i].WriteMsgPack();
|
||||
|
||||
@@ -226,7 +224,7 @@ namespace KKdMainLib.DB
|
||||
{ Id = msg.ReadNUInt16("Id"); Name = msg.ReadString("Name"); }
|
||||
|
||||
public MsgPack WriteMsgPack() =>
|
||||
new MsgPack().Add("Id", Id).Add("Name", Name);
|
||||
MsgPack.New.Add("Id", Id).Add("Name", Name);
|
||||
}
|
||||
|
||||
public struct AetSet
|
||||
@@ -248,23 +246,21 @@ namespace KKdMainLib.DB
|
||||
NewId = msg.ReadBoolean("NewId" );
|
||||
SpriteSetId = msg.ReadNUInt16("SpriteSetId");
|
||||
|
||||
if (msg.Element("Aets", out MsgPack Aets, typeof(object[])))
|
||||
if (msg.ElementArray("Aets", out MsgPack Aets))
|
||||
{
|
||||
object Aet;
|
||||
this .Aets = new AET[((object[])Aets.Object).Length];
|
||||
this.Aets = new AET[Aets.Array.Length];
|
||||
for (int i0 = 0; i0 < this.Aets.Length; i0++)
|
||||
{ Aet = Aets[i0]; if (Aet.GetType() == typeof(MsgPack))
|
||||
this.Aets[i0].ReadMsgPack((MsgPack)Aet); }
|
||||
this.Aets[i0].ReadMsgPack(Aets[i0]);
|
||||
}
|
||||
}
|
||||
|
||||
public MsgPack WriteMsgPack()
|
||||
{
|
||||
MsgPack Aets = new MsgPack("Aets", this.Aets.Length);
|
||||
MsgPack Aets = new MsgPack(this.Aets.Length, "Aets");
|
||||
for (int i0 = 0; i0 < this.Aets.Length; i0++)
|
||||
Aets[i0] = this.Aets[i0].WriteMsgPack();
|
||||
|
||||
return new MsgPack().Add("FileName", FileName).Add("Id", Id)
|
||||
return MsgPack.New.Add("FileName", FileName).Add("Id", Id)
|
||||
.Add("Name", Name).Add("SpriteSetId", SpriteSetId).Add(Aets);
|
||||
}
|
||||
}
|
||||
|
||||
+31
-43
@@ -1,13 +1,12 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using KKdBaseLib;
|
||||
using KKdMainLib.IO;
|
||||
using KKdMainLib.A3DA;
|
||||
using KKdMainLib.MessagePack;
|
||||
using MPIO = KKdMainLib.MessagePack.IO;
|
||||
|
||||
namespace KKdMainLib.DB
|
||||
{
|
||||
public struct Auth
|
||||
public class Auth
|
||||
{
|
||||
public int Signature { get; private set; }
|
||||
public string[] Category { get; private set; }
|
||||
@@ -21,7 +20,7 @@ namespace KKdMainLib.DB
|
||||
|
||||
IO = File.OpenReader(file + ".bin");
|
||||
|
||||
IO.Format = Main.Format.F;
|
||||
IO.Format = Format.F;
|
||||
Signature = IO.ReadInt32();
|
||||
if (Signature != 0x44334123) return;
|
||||
Signature = IO.ReadInt32();
|
||||
@@ -71,8 +70,7 @@ namespace KKdMainLib.DB
|
||||
{
|
||||
int[] SO = Category.Length.SortWriter();
|
||||
for (int i = 0; i < Category.Length; i++)
|
||||
if (Category[SO[i]] != null)
|
||||
IO.Write("category." + SO[i] + ".value=", Category[SO[i]]);
|
||||
IO.Write("category." + SO[i] + ".value=", Category[SO[i]]);
|
||||
IO.Write("category.length=", Category.Length);
|
||||
}
|
||||
|
||||
@@ -81,16 +79,12 @@ namespace KKdMainLib.DB
|
||||
int[] SO = _UID.Length.SortWriter();
|
||||
for (int i = 0; i < _UID.Length; i++)
|
||||
{
|
||||
if (_UID[SO[i]].Category != null)
|
||||
if (_UID[SO[i]].Category != "")
|
||||
IO.Write("uid." + SO[i] + ".category=", _UID[SO[i]].Category);
|
||||
if (_UID[SO[i]].OrgUid != null)
|
||||
IO.Write("uid." + SO[i] + ".org_uid=" , _UID[SO[i]].OrgUid );
|
||||
if (_UID[SO[i]].Size != null)
|
||||
IO.Write("uid." + SO[i] + ".size=" , _UID[SO[i]].Size );
|
||||
if (_UID[SO[i]].Value != null)
|
||||
if (_UID[SO[i]].Value != "")
|
||||
IO.Write("uid." + SO[i] + ".value=" , _UID[SO[i]].Value );
|
||||
if (_UID[SO[i]].Category != "")
|
||||
IO.Write("uid." + SO[i] + ".category=", _UID[SO[i]].Category);
|
||||
IO.Write("uid." + SO[i] + ".org_uid=" , _UID[SO[i]].OrgUid );
|
||||
IO.Write("uid." + SO[i] + ".size=" , _UID[SO[i]].Size );
|
||||
if (_UID[SO[i]].Value != "")
|
||||
IO.Write("uid." + SO[i] + ".value=" , _UID[SO[i]].Value );
|
||||
}
|
||||
IO.Write("uid.length=", _UID.Length);
|
||||
}
|
||||
@@ -100,35 +94,30 @@ namespace KKdMainLib.DB
|
||||
|
||||
public void MsgPackReader(string file, bool JSON)
|
||||
{
|
||||
MsgPack MsgPack = file.ReadMP(JSON);
|
||||
MsgPack MsgPack = file.ReadMPAllAtOnce(JSON);
|
||||
|
||||
if (MsgPack.Element("AuthDB", out MsgPack AuthDB))
|
||||
{
|
||||
if (AuthDB.Element("Category", out MsgPack Temp, typeof(object[])))
|
||||
if (AuthDB.ElementArray("Category", out MsgPack Temp))
|
||||
{
|
||||
this.Category = new string[((object[])Temp.Object).Length];
|
||||
MsgPack Category;
|
||||
for (int i = 0; i < this.Category.Length; i++)
|
||||
if (Temp[i].GetType() == typeof(MsgPack))
|
||||
{ Category = (MsgPack)Temp[i]; this.Category[i] = Category.ReadString(); }
|
||||
Category = new string[Temp.Array.Length];
|
||||
for (int i = 0; i < Category.Length; i++)
|
||||
Category[i] = Temp[i].ReadString();
|
||||
}
|
||||
|
||||
if (AuthDB.Element("UID", out Temp, typeof(object[])))
|
||||
if (AuthDB.ElementArray("UID", out Temp))
|
||||
{
|
||||
_UID = new UID[((object[])Temp.Object).Length];
|
||||
MsgPack UID;
|
||||
_UID = new UID[Temp.Array.Length];
|
||||
for (int i = 0; i < _UID.Length; i++)
|
||||
if (Temp[i].GetType() == typeof(MsgPack))
|
||||
{
|
||||
UID = (MsgPack)Temp[i];
|
||||
_UID[i].Category = UID.ReadString("C");
|
||||
_UID[i].OrgUid = UID.ReadNInt32("O");
|
||||
_UID[i].Size = UID.ReadNInt32("S");
|
||||
_UID[i].Value = UID.ReadString("V");
|
||||
}
|
||||
{
|
||||
_UID[i].Category = Temp[i].ReadString("Category");
|
||||
_UID[i].OrgUid = Temp[i].ReadNInt32("OrgUid" );
|
||||
_UID[i].Size = Temp[i].ReadNInt32("Size" );
|
||||
_UID[i].Value = Temp[i].ReadString("Value" );
|
||||
}
|
||||
}
|
||||
}
|
||||
MsgPack = null;
|
||||
MsgPack.Dispose();
|
||||
}
|
||||
|
||||
public void MsgPackWriter(string file, bool JSON)
|
||||
@@ -136,21 +125,20 @@ namespace KKdMainLib.DB
|
||||
MsgPack AuthDB = new MsgPack("AuthDB");
|
||||
if (Category != null)
|
||||
{
|
||||
MsgPack Category = new MsgPack("Category", this.Category.Length);
|
||||
MsgPack Category = new MsgPack(this.Category.Length, "Category");
|
||||
for (int i = 0; i < this.Category.Length; i++)
|
||||
Category[i] = this.Category[i];
|
||||
Category[i] = (MsgPack)this.Category[i];
|
||||
AuthDB.Add(Category);
|
||||
}
|
||||
|
||||
if (_UID != null)
|
||||
{
|
||||
MsgPack UID = new MsgPack("UID", _UID.Length);
|
||||
MsgPack UID = new MsgPack(_UID.Length, "UID");
|
||||
for (int i = 0; i < _UID.Length; i++)
|
||||
UID[i] = new MsgPack()
|
||||
.Add("C", _UID[i].Category)
|
||||
.Add("O", _UID[i].OrgUid )
|
||||
.Add("S", _UID[i].Size )
|
||||
.Add("V", _UID[i].Value );
|
||||
UID[i] = MsgPack.New.Add("Category", _UID[i].Category)
|
||||
.Add("OrgUid" , _UID[i].OrgUid )
|
||||
.Add("Size" , _UID[i].Size )
|
||||
.Add("Value" , _UID[i].Value );
|
||||
AuthDB.Add(UID);
|
||||
}
|
||||
|
||||
|
||||
@@ -1,248 +0,0 @@
|
||||
// Original: https://github.com/blueskythlikesclouds/MikuMikuLibrary
|
||||
|
||||
using System.Collections.Generic;
|
||||
using KKdMainLib.IO;
|
||||
using KKdMainLib.Types;
|
||||
using KKdMainLib.MessagePack;
|
||||
using MPIO = KKdMainLib.MessagePack.IO;
|
||||
|
||||
namespace KKdMainLib.DB
|
||||
{
|
||||
public class BoneData
|
||||
{
|
||||
public Stream IO;
|
||||
public BONE Data;
|
||||
|
||||
private int i, i0;
|
||||
|
||||
public BoneData()
|
||||
{ Data = new BONE(); }
|
||||
|
||||
public void BONReader(string file, string ext)
|
||||
{
|
||||
Data = new BONE { Header = new PDHead() };
|
||||
IO = File.OpenReader(file + ext);
|
||||
|
||||
IO.Format = Main.Format.F;
|
||||
Data.Header.Signature = IO.ReadInt32();
|
||||
if (Data.Header.Signature == 0x454E4F42)
|
||||
{
|
||||
Data.Header = IO.ReadHeader(true);
|
||||
Data.POF = Data.Header.AddPOF();
|
||||
}
|
||||
if (Data.Header.Signature != 0x09102720)
|
||||
return;
|
||||
|
||||
Data.Skeleton = new SkeletonEntry[IO.ReadInt32Endian()];
|
||||
Data.SkeletonsOffset = IO.ReadUInt32Endian(ref Data.POF);
|
||||
Data.SkeletonNamesOffset = IO.ReadUInt32Endian();
|
||||
if (Data.SkeletonNamesOffset == 0)
|
||||
{
|
||||
IO.IsX = true;
|
||||
IO.Format = Main.Format.X;
|
||||
Data.POF.POFOffsets = new List<long>();
|
||||
IO.Seek(Data.Header.Lenght, 0);
|
||||
IO.LongOffset = Data.Header.Lenght;
|
||||
Data.Header.Signature = IO.ReadInt32();
|
||||
Data.Skeleton = new SkeletonEntry[IO.ReadInt32Endian()];
|
||||
Data.SkeletonsOffset = IO.ReadInt64();
|
||||
Data.SkeletonNamesOffset = IO.ReadInt64(ref Data.POF);
|
||||
}
|
||||
else
|
||||
{
|
||||
IO.LongPosition -= 4;
|
||||
IO.GetOffset(ref Data.POF);
|
||||
IO.LongPosition += 4;
|
||||
}
|
||||
|
||||
Data.SkeletonEntryOffset = new long[Data.Skeleton.Length];
|
||||
IO.LongPosition = Data.SkeletonsOffset;
|
||||
for (i0 = 0; i0 < Data.Skeleton.Length; i0++)
|
||||
Data.SkeletonEntryOffset[i0] = IO.ReadIntX(ref Data.POF);
|
||||
|
||||
for (i0 = 0; i0 < Data.Skeleton.Length; i0++)
|
||||
{
|
||||
Data.Skeleton[i0] = new SkeletonEntry();
|
||||
IO.LongPosition = Data.SkeletonEntryOffset[i0];
|
||||
|
||||
Data.Skeleton[i0].BoneOffset = IO.ReadIntX(ref Data.POF);
|
||||
Data.Skeleton[i0].Position = new Vector3<float>[IO.ReadIntX()];
|
||||
Data.Skeleton[i0].PositionOffset = IO.ReadIntX(ref Data.POF);
|
||||
Data.Skeleton[i0].Field02Offset = IO.ReadIntX(ref Data.POF);
|
||||
Data.Skeleton[i0].BoneName1 = new string[IO.ReadIntX()];
|
||||
Data.Skeleton[i0].BoneName1Offset = IO.ReadIntX(ref Data.POF);
|
||||
Data.Skeleton[i0].BoneName2 = new string[IO.ReadIntX()];
|
||||
Data.Skeleton[i0].BoneName2Offset = IO.ReadIntX(ref Data.POF);
|
||||
Data.Skeleton[i0].ParentIndiceOffset = IO.ReadIntX(ref Data.POF);
|
||||
|
||||
IO.LongPosition = Data.SkeletonNamesOffset + i0 << (IO.IsX ? 3 : 2);
|
||||
|
||||
Data.Skeleton[i0].Name = IO.ReadStringAtOffset(ref Data.POF);
|
||||
IO.LongPosition = Data.Skeleton[i0].BoneOffset;
|
||||
|
||||
long Count = 0;
|
||||
string Name = "";
|
||||
while (true)
|
||||
{
|
||||
IO.ReadUInt64();
|
||||
Name = IO.ReadStringAtOffset(ref Data.POF);
|
||||
if (Name == "End") break;
|
||||
Count++;
|
||||
}
|
||||
|
||||
Data.Skeleton[i0].Bone = new BoneEntry[Count];
|
||||
for (i = 0; i < Count; i++)
|
||||
{
|
||||
Data.Skeleton[i0].Bone[i].Type = (BoneType)IO.ReadByte ();
|
||||
Data.Skeleton[i0].Bone[i].HasParent = IO.ReadBoolean();
|
||||
Data.Skeleton[i0].Bone[i].ParentNameIndex = IO.ReadByte ();
|
||||
Data.Skeleton[i0].Bone[i].Field01 = IO.ReadByte ();
|
||||
Data.Skeleton[i0].Bone[i].PairNameIndex = IO.ReadByte ();
|
||||
Data.Skeleton[i0].Bone[i].Field02 = IO.ReadByte ();
|
||||
IO.ReadInt16Endian();
|
||||
Data.Skeleton[i0].Bone[i].Name = IO.ReadStringAtOffset(ref Data.POF);
|
||||
}
|
||||
|
||||
IO.LongPosition = Data.Skeleton[i0].PositionOffset;
|
||||
for (i = 0; i < Data.Skeleton[i0].Position.Length; i++)
|
||||
Data.Skeleton[i0].Position[i] = new Vector3<float>(IO.ReadSingleEndian(),
|
||||
IO.ReadSingleEndian(), IO.ReadSingleEndian());
|
||||
|
||||
IO.LongPosition = Data.Skeleton[i0].Field02Offset;
|
||||
Data.Skeleton[i0].Field02 = IO.ReadIntX();
|
||||
|
||||
IO.LongPosition = Data.Skeleton[i0].BoneName1Offset;
|
||||
for (i = 0; i < Data.Skeleton[i0].BoneName1.Length; i++)
|
||||
Data.Skeleton[i0].BoneName1[i] = IO.ReadStringAtOffset(ref Data.POF);
|
||||
|
||||
IO.LongPosition = Data.Skeleton[i0].BoneName2Offset;
|
||||
for (i = 0; i < Data.Skeleton[i0].BoneName2.Length; i++)
|
||||
Data.Skeleton[i0].BoneName2[i] = IO.ReadStringAtOffset(ref Data.POF);
|
||||
|
||||
IO.LongPosition = Data.Skeleton[i0].ParentIndiceOffset;
|
||||
for (i = 0; i < Data.Skeleton[i0].BoneName2.Length; i++)
|
||||
Data.Skeleton[i0].ParentIndice[i] = IO.ReadInt16Endian();
|
||||
}
|
||||
if (IO.Format > Main.Format.F)
|
||||
{
|
||||
IO.LongPosition = Data.POF.Offset;
|
||||
IO.ReadPOF(ref Data.POF);
|
||||
}
|
||||
IO.Close();
|
||||
}
|
||||
|
||||
public void BONWriter(string file, Main.Format Format)
|
||||
{
|
||||
IO = File.OpenWriter(file + ".bon", true);
|
||||
IO.Close();
|
||||
}
|
||||
|
||||
public void MsgPackReader(string file, bool JSON)
|
||||
{
|
||||
MsgPack MsgPack = file.ReadMP(JSON);
|
||||
|
||||
MsgPack = null;
|
||||
}
|
||||
|
||||
public void MsgPackWriter(string file, bool JSON)
|
||||
{
|
||||
MsgPack BoneDB = new MsgPack("BoneDB", Data.Skeleton.Length);
|
||||
for (i0 = 0; i0 < Data.Skeleton.Length; i0++)
|
||||
{
|
||||
MsgPack Skeleton = new MsgPack().Add("Name" , Data.Skeleton[i0].Name )
|
||||
.Add("Field02", Data.Skeleton[i0].Field02);
|
||||
|
||||
MsgPack Bone = new MsgPack("Bone", Data.Skeleton[i0].Bone.Length);
|
||||
for (i = 0; i < Data.Skeleton[i0].Bone.Length; i++)
|
||||
Bone[i] = new MsgPack().Add("Type" , (byte) Data.Skeleton[i0].Bone[i].Type )
|
||||
.Add("HasParent" , Data.Skeleton[i0].Bone[i].HasParent )
|
||||
.Add("ParentNameIndex", Data.Skeleton[i0].Bone[i].ParentNameIndex)
|
||||
.Add("Field01" , Data.Skeleton[i0].Bone[i].Field01 )
|
||||
.Add("PairNameIndex" , Data.Skeleton[i0].Bone[i].PairNameIndex )
|
||||
.Add("Field02" , Data.Skeleton[i0].Bone[i].Field02 )
|
||||
.Add("Name" , Data.Skeleton[i0].Bone[i].Name );
|
||||
Skeleton.Add(Bone);
|
||||
|
||||
MsgPack Position = new MsgPack("Position", Data.Skeleton[i0].Position.Length);
|
||||
for (i = 0; i < Data.Skeleton[i0].Position.Length; i++)
|
||||
Position[i] = new MsgPack().Add("X", Data.Skeleton[i0].Position[i].X)
|
||||
.Add("Y", Data.Skeleton[i0].Position[i].Y)
|
||||
.Add("Z", Data.Skeleton[i0].Position[i].Z);
|
||||
Skeleton.Add(Position);
|
||||
|
||||
MsgPack BoneName1 = new MsgPack("BoneName1", Data.Skeleton[i0].BoneName1.Length);
|
||||
for (i = 0; i < Data.Skeleton[i0].BoneName1.Length; i++)
|
||||
BoneName1[i] = Data.Skeleton[i0].BoneName1[i];
|
||||
Skeleton.Add(BoneName1);
|
||||
|
||||
MsgPack BoneName2 = new MsgPack("BoneName2", Data.Skeleton[i0].BoneName2.Length);
|
||||
for (i = 0; i < Data.Skeleton[i0].BoneName2.Length; i++)
|
||||
BoneName2[i] = Data.Skeleton[i0].BoneName2[i];
|
||||
Skeleton.Add(BoneName2);
|
||||
|
||||
MsgPack ParentIndice = new MsgPack("ParentIndice", Data.Skeleton[i0].ParentIndice.Length);
|
||||
for (i = 0; i < Data.Skeleton[i0].ParentIndice.Length; i++)
|
||||
ParentIndice[i] = Data.Skeleton[i0].ParentIndice[i];
|
||||
BoneDB[i0] = Skeleton.Add(ParentIndice);
|
||||
}
|
||||
|
||||
BoneDB.Write(true, file, JSON);
|
||||
}
|
||||
|
||||
/*public struct Bone
|
||||
{
|
||||
public List<string> Names;
|
||||
public List<long> Offsets;
|
||||
}*/
|
||||
|
||||
public struct BONE
|
||||
{
|
||||
public long SkeletonsOffset;
|
||||
public long SkeletonNamesOffset;
|
||||
public POF POF;
|
||||
public PDHead Header;
|
||||
public long[] SkeletonEntryOffset;
|
||||
public SkeletonEntry[] Skeleton;
|
||||
}
|
||||
|
||||
public struct BoneEntry
|
||||
{
|
||||
public bool HasParent;
|
||||
public byte Field01;
|
||||
public byte Field02;
|
||||
public byte PairNameIndex;
|
||||
public byte ParentNameIndex;
|
||||
public string Name;
|
||||
public BoneType Type;
|
||||
}
|
||||
|
||||
public enum BoneType : byte
|
||||
{
|
||||
Rotation = 0,
|
||||
Type1 = 1,
|
||||
Position = 2,
|
||||
Type3 = 3,
|
||||
Type4 = 4,
|
||||
Type5 = 5,
|
||||
Type6 = 6,
|
||||
};
|
||||
|
||||
public struct SkeletonEntry
|
||||
{
|
||||
public long BoneOffset;
|
||||
public long Field02Offset;
|
||||
public long PositionOffset;
|
||||
public long BoneName1Offset;
|
||||
public long BoneName2Offset;
|
||||
public long ParentIndiceOffset;
|
||||
|
||||
public long Field02;
|
||||
public string Name;
|
||||
public short[] ParentIndice;
|
||||
public string[] BoneName1;
|
||||
public string[] BoneName2;
|
||||
public BoneEntry[] Bone;
|
||||
public Vector3<float>[] Position;
|
||||
}
|
||||
}
|
||||
}
|
||||
+35
-59
@@ -1,9 +1,8 @@
|
||||
//Original: https://github.com/blueskythlikesclouds/MikuMikuLibrary/
|
||||
|
||||
using System.Collections.Generic;
|
||||
using KKdBaseLib;
|
||||
using KKdMainLib.IO;
|
||||
using KKdMainLib.MessagePack;
|
||||
using MPIO = KKdMainLib.MessagePack.IO;
|
||||
|
||||
namespace KKdMainLib.DB
|
||||
{
|
||||
@@ -16,26 +15,6 @@ namespace KKdMainLib.DB
|
||||
|
||||
public void BINReader(string file)
|
||||
{
|
||||
/*Stream IO0 = File.OpenReader(file + "0.bin");
|
||||
Stream IO1 = File.OpenReader(file + "1.bin");
|
||||
|
||||
List<int> _0 = new List<int>();
|
||||
List<int> _1 = new List<int>();
|
||||
IO0.Position = 0x20;
|
||||
for (i = 0; i < 124; i++)
|
||||
{ _0.Add(IO0.ReadInt32()); IO0.LongPosition += 8; }
|
||||
IO1.Position = 0x20;
|
||||
for (i = 0; i < 124; i++)
|
||||
{ _1.Add(IO1.ReadInt32()); IO1.LongPosition += 8; }
|
||||
IO0.Close();
|
||||
IO1.Close();
|
||||
|
||||
IO = File.OpenWriter(@"F:\Source\MikuMikuModel\DatabaseConverter\msgpack-json-tools\aet_gam_pv643.bin");
|
||||
IO.Position = 0x10;
|
||||
for (i = 0; i < 108; i++)
|
||||
{ IO.ReadInt32(); i1 = _1[_0.IndexOf(IO.ReadInt32())]; IO.Position -= 4; IO.Write(i1); }
|
||||
IO.Close();*/
|
||||
|
||||
IO = File.OpenReader(file + ".bin");
|
||||
|
||||
int spriteSetsLength = IO.ReadInt32();
|
||||
@@ -105,8 +84,8 @@ namespace KKdMainLib.DB
|
||||
List<string> SetName = new List<string>();
|
||||
List<string> SetFileName = new List<string>();
|
||||
|
||||
List<int> Ids = new List<int>();
|
||||
List<int> SetIds = new List<int>();
|
||||
List<int> Ids = new List<int>();
|
||||
List<int> SetIds = new List<int>();
|
||||
|
||||
List<int> NotAdd = new List<int>();
|
||||
SpriteTexture temp;
|
||||
@@ -141,7 +120,7 @@ namespace KKdMainLib.DB
|
||||
if ( Ids.Contains((int)temp.Id)) { NotAdd.Add(i); break; }
|
||||
else Ids.Add ((int)temp.Id);
|
||||
}
|
||||
if (i0 + 1 != set.Sprites.Length) continue;
|
||||
if (i0 < set.Sprites.Length) continue;
|
||||
|
||||
for (i0 = 0; i0 < set.Textures.Length; i0++)
|
||||
{
|
||||
@@ -164,13 +143,13 @@ namespace KKdMainLib.DB
|
||||
if (set.Id == null) while (true)
|
||||
{ if (!SetIds.Contains(i1)) { SpriteSets[i].Id = i1; SetIds.Add(i1); break; } i1++; }
|
||||
|
||||
for (i0 = 0, i1 = 0; i0 < set. Sprites.Length; i0++)
|
||||
if (set. Sprites[i0].Id == null) while (true) { if (!Ids.Contains(i1))
|
||||
{ SpriteSets[i]. Sprites[i0].Id = i1; Ids.Add(i1); break; } i1++; }
|
||||
|
||||
for (i0 = 0, i1 = 0; i0 < set.Textures.Length; i0++)
|
||||
if (set.Textures[i0].Id == null) while (true) { if (!Ids.Contains(i1))
|
||||
{ SpriteSets[i].Textures[i0].Id = i1; Ids.Add(i1); break; } i1++; }
|
||||
while (set.Textures[i0].Id == null)
|
||||
if (!Ids.Contains(i1)) Ids.Add((int)(SpriteSets[i].Textures[i0].Id = i1)); else i1++;
|
||||
|
||||
for (i0 = 0, i1 = 0; i0 < set. Sprites.Length; i0++)
|
||||
while (set. Sprites[i0].Id == null)
|
||||
if (!Ids.Contains(i1)) Ids.Add((int)(SpriteSets[i]. Sprites[i0].Id = i1)); else i1++;
|
||||
}
|
||||
|
||||
Ids = null;
|
||||
@@ -196,18 +175,20 @@ namespace KKdMainLib.DB
|
||||
for (i = 0; i < SpriteSets.Length; i++)
|
||||
{
|
||||
if (NotAdd.Contains(i)) continue;
|
||||
SpriteSets[i]. NameOffset = IO.Position; IO.Write(SpriteSets[i]. Name + "\0");
|
||||
SpriteSets[i].FileNameOffset = IO.Position; IO.Write(SpriteSets[i].FileName + "\0");
|
||||
for (i0 = 0; i0 < SpriteSets[i].Textures.Length; i0++)
|
||||
{ SpriteSets[i].Textures[i0].NameOffset = IO.Position;
|
||||
IO.Write(SpriteSets[i].Textures[i0].Name + "\0"); }
|
||||
|
||||
for (i0 = 0; i0 < SpriteSets[i]. Sprites.Length; i0++)
|
||||
{ SpriteSets[i]. Sprites[i0].NameOffset = IO.Position;
|
||||
IO.Write(SpriteSets[i]. Sprites[i0].Name + "\0"); }
|
||||
}
|
||||
|
||||
for (i = 0; i < SpriteSets.Length; i++)
|
||||
{
|
||||
if (NotAdd.Contains(i)) continue;
|
||||
for (i0 = 0; i0 < SpriteSets[i].Textures.Length; i0++)
|
||||
{ SpriteSets[i].Textures[i0].NameOffset = IO.Position; IO.Write(SpriteSets[i].Textures[i0].Name + "\0"); }
|
||||
|
||||
for (i0 = 0; i0 < SpriteSets[i]. Sprites.Length; i0++)
|
||||
{ SpriteSets[i]. Sprites[i0].NameOffset = IO.Position; IO.Write(SpriteSets[i]. Sprites[i0].Name + "\0"); }
|
||||
SpriteSets[i]. NameOffset = IO.Position; IO.Write(SpriteSets[i]. Name + "\0");
|
||||
SpriteSets[i].FileNameOffset = IO.Position; IO.Write(SpriteSets[i].FileName + "\0");
|
||||
}
|
||||
|
||||
IO.Align(0x08, true);
|
||||
@@ -248,16 +229,15 @@ namespace KKdMainLib.DB
|
||||
|
||||
public void MsgPackReader(string file, bool JSON = false)
|
||||
{
|
||||
MsgPack MsgPack = file.ReadMP(JSON);
|
||||
MsgPack MsgPack = file.ReadMPAllAtOnce(JSON);
|
||||
|
||||
if (MsgPack.Element("SprDB", out MsgPack SprDB, typeof(object[])))
|
||||
if (MsgPack.ElementArray("SprDB", out MsgPack SprDB))
|
||||
{
|
||||
SpriteSets = new SpriteSet[((object[])SprDB.Object).Length];
|
||||
SpriteSets = new SpriteSet[SprDB.Array.Length];
|
||||
for (int i = 0; i < SpriteSets.Length; i++)
|
||||
if (SprDB[i].GetType() == typeof(MsgPack))
|
||||
SpriteSets[i].ReadMsgPack((MsgPack)SprDB[i]);
|
||||
SpriteSets[i].ReadMsgPack(SprDB[i]);
|
||||
}
|
||||
MsgPack = null;
|
||||
MsgPack.Dispose();
|
||||
}
|
||||
|
||||
public void MsgPackWriter(string file, bool JSON)
|
||||
@@ -265,7 +245,7 @@ namespace KKdMainLib.DB
|
||||
if (SpriteSets == null) return;
|
||||
if (SpriteSets.Length == 0) return;
|
||||
|
||||
MsgPack SprDB = new MsgPack("SprDB", SpriteSets.Length);
|
||||
MsgPack SprDB = new MsgPack(SpriteSets.Length, "SprDB");
|
||||
for (i = 0; i < SpriteSets.Length; i++) SprDB[i] = SpriteSets[i].WriteMsgPack();
|
||||
|
||||
SprDB.Write(true, file, JSON);
|
||||
@@ -281,7 +261,7 @@ namespace KKdMainLib.DB
|
||||
{ Id = msg.ReadNInt32("Id"); Name = msg.ReadString("Name"); }
|
||||
|
||||
public MsgPack WriteMsgPack() =>
|
||||
new MsgPack().Add("Id", Id).Add("Name", Name);
|
||||
MsgPack.New.Add("Id", Id).Add("Name", Name);
|
||||
}
|
||||
|
||||
public struct SpriteSet
|
||||
@@ -302,36 +282,32 @@ namespace KKdMainLib.DB
|
||||
Name = msg.ReadString ("Name" );
|
||||
NewId = msg.ReadBoolean("NewId" );
|
||||
|
||||
if (msg.Element( "Sprites", out MsgPack Sprites, typeof(object[])))
|
||||
if (msg.ElementArray( "Sprites", out MsgPack Sprites))
|
||||
{
|
||||
object Sprite;
|
||||
this .Sprites = new SpriteTexture[((object[])Sprites.Object).Length];
|
||||
this.Sprites = new SpriteTexture[Sprites.Array.Length];
|
||||
for (int i0 = 0; i0 < this.Sprites.Length; i0++)
|
||||
{ Sprite = Sprites[i0]; if (Sprites.GetType() == typeof(MsgPack))
|
||||
this.Sprites[i0].ReadMsgPack((MsgPack)Sprite); }
|
||||
this.Sprites[i0].ReadMsgPack(Sprites[i0]);
|
||||
}
|
||||
|
||||
if (msg.Element("Textures", out MsgPack Textures, typeof(object[])))
|
||||
if (msg.ElementArray("Textures", out MsgPack Textures))
|
||||
{
|
||||
object Texture;
|
||||
this .Textures = new SpriteTexture[((object[])Textures.Object).Length];
|
||||
this.Textures = new SpriteTexture[Textures.Array.Length];
|
||||
for (int i0 = 0; i0 < this.Textures.Length; i0++)
|
||||
{ Texture = Textures[i0]; if (Texture.GetType() == typeof(MsgPack))
|
||||
this.Textures[i0].ReadMsgPack((MsgPack)Texture); }
|
||||
this.Textures[i0].ReadMsgPack(Textures[i0]);
|
||||
}
|
||||
}
|
||||
|
||||
public MsgPack WriteMsgPack()
|
||||
{
|
||||
MsgPack Sprites = new MsgPack( "Sprites", this.Sprites.Length);
|
||||
MsgPack Sprites = new MsgPack(this. Sprites.Length, "Sprites");
|
||||
for (int i0 = 0; i0 < this.Sprites.Length; i0++)
|
||||
Sprites[i0] = this.Sprites[i0].WriteMsgPack();
|
||||
|
||||
MsgPack Textures = new MsgPack("Textures", this.Textures.Length);
|
||||
MsgPack Textures = new MsgPack(this.Textures.Length, "Textures");
|
||||
for (int i0 = 0; i0 < this.Textures.Length; i0++)
|
||||
Textures[i0] = this.Textures[i0].WriteMsgPack();
|
||||
|
||||
return new MsgPack().Add("FileName", FileName).Add("Id", Id).Add("Name", Name).Add(Sprites).Add(Textures);
|
||||
return MsgPack.New.Add("FileName", FileName).Add("Id", Id).Add("Name", Name).Add(Sprites).Add(Textures);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+85
-113
@@ -1,41 +1,39 @@
|
||||
using System.Collections.Generic;
|
||||
using KKdBaseLib;
|
||||
using KKdBaseLib.F2;
|
||||
using KKdMainLib.IO;
|
||||
using KKdMainLib.MessagePack;
|
||||
using MPIO = KKdMainLib.MessagePack.IO;
|
||||
|
||||
namespace KKdMainLib
|
||||
{
|
||||
public class DEX
|
||||
{
|
||||
public DEX()
|
||||
{ Dex = null; Header = new PDHead(); }
|
||||
{ Dex = null; Header = new Header(); }
|
||||
|
||||
private int Offset = 0;
|
||||
private PDHead Header;
|
||||
|
||||
public Stream IO;
|
||||
private Header Header;
|
||||
private Stream IO;
|
||||
|
||||
public EXP[] Dex;
|
||||
|
||||
public int DEXReader(string filepath, string ext)
|
||||
{
|
||||
Header = new PDHead();
|
||||
Header = new Header();
|
||||
IO = File.OpenReader(filepath + ext);
|
||||
|
||||
Header.Format = Main.Format.F;
|
||||
Header.Signature = IO.ReadInt32();
|
||||
if (Header.Signature == 0x43505845)
|
||||
Header = IO.ReadHeader(true);
|
||||
if (Header.Signature != 0x64)
|
||||
return 0;
|
||||
Header.Format = Format.F;
|
||||
Header.SectionSignature = IO.ReadInt32();
|
||||
if (Header.SectionSignature == 0x43505845)
|
||||
Header = IO.ReadHeader(true, true);
|
||||
if (Header.SectionSignature != 0x64) return 0;
|
||||
|
||||
Offset = IO.Position - 0x4;
|
||||
IO.Offset = IO.Position - 0x4;
|
||||
Dex = new EXP[IO.ReadInt32()];
|
||||
int DEXOffset = IO.ReadInt32();
|
||||
if (IO.ReadInt32() == 0x00) Header.Format = Main.Format.X;
|
||||
int DEXNameOffset = IO.ReadInt32();
|
||||
if (Header.IsX) IO.ReadInt32();
|
||||
if (DEXNameOffset == 0x00) { Header.Format = Format.X; DEXNameOffset = (int)IO.ReadInt64(); }
|
||||
|
||||
IO.Seek(DEXOffset + Offset, 0);
|
||||
IO.Seek(DEXOffset, 0);
|
||||
for (int i0 = 0; i0 < Dex.Length; i0++)
|
||||
Dex[i0] = new EXP { Main = new List<EXPElement>(), Eyes = new List<EXPElement>() };
|
||||
|
||||
@@ -46,7 +44,7 @@ namespace KKdMainLib
|
||||
Dex[i0].EyesOffset = IO.ReadInt32();
|
||||
if (Header.IsX) IO.ReadInt32();
|
||||
}
|
||||
IO.Seek(DEXNameOffset + Offset, 0);
|
||||
IO.Seek(DEXNameOffset, 0);
|
||||
for (int i0 = 0; i0 < Dex.Length; i0++)
|
||||
{
|
||||
Dex[i0].NameOffset = IO.ReadInt32();
|
||||
@@ -70,7 +68,7 @@ namespace KKdMainLib
|
||||
break;
|
||||
}
|
||||
|
||||
IO.Seek(Dex[i0].EyesOffset + Offset, 0);
|
||||
IO.Seek(Dex[i0].EyesOffset, 0);
|
||||
while(true)
|
||||
{
|
||||
element.Frame = IO.ReadSingle();
|
||||
@@ -80,54 +78,40 @@ namespace KKdMainLib
|
||||
element.Trans = IO.ReadSingle();
|
||||
Dex[i0].Eyes.Add(element);
|
||||
|
||||
if (element.Frame == 999999 || element.Both == 0xFFFF)
|
||||
break;
|
||||
if (element.Frame == 999999 || element.Both == 0xFFFF) break;
|
||||
}
|
||||
|
||||
IO.Seek(Dex[i0].NameOffset + Offset, 0);
|
||||
Dex[i0].Name = IO.NullTerminatedUTF8();
|
||||
Dex[i0].Name = IO.ReadStringAtOffset(Dex[i0].NameOffset);
|
||||
}
|
||||
|
||||
IO.Close();
|
||||
return 1;
|
||||
}
|
||||
|
||||
public void DEXWriter(string filepath, Main.Format Format)
|
||||
public void DEXWriter(string filepath, Format Format)
|
||||
{
|
||||
Header = new PDHead() { Format = Format };
|
||||
IO = File.OpenWriter(filepath + (Header.Format > Main.Format.F ? ".Dex" : ".bin"), true);
|
||||
IO.Format = Header.Format;
|
||||
|
||||
if (IO.Format > Main.Format.F)
|
||||
{
|
||||
Header.Lenght = 0x20;
|
||||
Header.DataSize = 0x00;
|
||||
Header.Signature = 0x43505845;
|
||||
Header.SectionSize = 0x00;
|
||||
IO.Write(Header);
|
||||
}
|
||||
Header = new Header();
|
||||
IO = File.OpenWriter(filepath + (Format > Format.F ? ".dex" : ".bin"), true);
|
||||
Header.Format = IO.Format = Format;
|
||||
|
||||
IO.Offset = Format > Format.F ? 0x20 : 0;
|
||||
IO.Write(0x64);
|
||||
IO.Write(Dex.Length);
|
||||
|
||||
if (Header.IsX) IO.Write((long)0x28);
|
||||
else IO.Write( 0x20);
|
||||
if (Header.IsX) IO.Write((long)0x00);
|
||||
else IO.Write( 0x00);
|
||||
|
||||
IO.WriteX(Header.IsX ? 0x28 : 0x20);
|
||||
IO.WriteX(0x00);
|
||||
|
||||
int Position0 = IO.Position;
|
||||
IO.Write((long)0x00);
|
||||
IO.Write((long)0x00);
|
||||
IO.Write(0x00L);
|
||||
IO.Write(0x00L);
|
||||
|
||||
for (int i = 0; i < Dex.Length * 3; i++)
|
||||
if (Header.IsX) IO.Write((long)0x00);
|
||||
else IO.Write( 0x00);
|
||||
for (int i = 0; i < Dex.Length * 3; i++) IO.WriteX(0x00);
|
||||
|
||||
IO.Align(0x20, true);
|
||||
|
||||
for (int i0 = 0; i0 < Dex.Length; i0++)
|
||||
{
|
||||
Dex[i0].MainOffset = IO.Position - Header.Lenght;
|
||||
Dex[i0].MainOffset = IO.Position;
|
||||
for (int i1 = 0; i1 < Dex[i0].Main.Count; i1++)
|
||||
{
|
||||
IO.Write(Dex[i0].Main[i1].Frame);
|
||||
@@ -138,7 +122,7 @@ namespace KKdMainLib
|
||||
}
|
||||
IO.Align(0x20, true);
|
||||
|
||||
Dex[i0].EyesOffset = IO.Position - Header.Lenght;
|
||||
Dex[i0].EyesOffset = IO.Position;
|
||||
for (int i1 = 0; i1 < Dex[i0].Eyes.Count; i1++)
|
||||
{
|
||||
IO.Write(Dex[i0].Eyes[i1].Frame);
|
||||
@@ -151,107 +135,87 @@ namespace KKdMainLib
|
||||
}
|
||||
for (int i0 = 0; i0 < Dex.Length; i0++)
|
||||
{
|
||||
Dex[i0].NameOffset = IO.Position - Header.Lenght;
|
||||
Dex[i0].NameOffset = IO.Position;
|
||||
IO.Write(Dex[i0].Name + "\0");
|
||||
}
|
||||
IO.Align(0x10, true);
|
||||
|
||||
if (Header.IsX) IO.Seek(Header.Lenght + 0x28, 0);
|
||||
else IO.Seek(Header.Lenght + 0x20, 0);
|
||||
IO.Position = Header.IsX ? 0x28 : 0x20;
|
||||
for (int i0 = 0; i0 < Dex.Length; i0++)
|
||||
{
|
||||
IO.Write(Dex[i0].MainOffset);
|
||||
if (Header.IsX) IO.Write(0x00);
|
||||
IO.Write(Dex[i0].EyesOffset);
|
||||
if (Header.IsX) IO.Write(0x00);
|
||||
IO.WriteX(Dex[i0].MainOffset);
|
||||
IO.WriteX(Dex[i0].EyesOffset);
|
||||
}
|
||||
int Position1 = IO.Position - Header.Lenght;
|
||||
int Position1 = IO.Position;
|
||||
for (int i0 = 0; i0 < Dex.Length; i0++)
|
||||
{
|
||||
IO.Write(Dex[i0].NameOffset);
|
||||
if (Header.IsX) IO.Write(0x00);
|
||||
}
|
||||
IO.WriteX(Dex[i0].NameOffset);
|
||||
|
||||
if (Header.IsX) IO.Seek(Position0 - 8, 0);
|
||||
else IO.Seek(Position0 - 4, 0);
|
||||
IO.Position = Position0 - (Header.IsX ? 8 : 4);
|
||||
IO.Write(Position1);
|
||||
|
||||
if (IO.Format > Main.Format.F)
|
||||
if (Format > Format.F)
|
||||
{
|
||||
Offset = IO.Length - Header.Lenght;
|
||||
IO.Seek(IO.Length, 0);
|
||||
Offset = IO.Length;
|
||||
IO.Offset = 0;
|
||||
IO.Position = IO.Length;
|
||||
IO.WriteEOFC(0);
|
||||
IO.Seek(0, 0);
|
||||
IO.Position = 0;
|
||||
Header.DataSize = Offset;
|
||||
Header.SectionSize = Offset;
|
||||
IO.Write(Header);
|
||||
Header.Signature = 0x43505845;
|
||||
IO.Write(Header, true);
|
||||
}
|
||||
IO.Close();
|
||||
}
|
||||
|
||||
public void MsgPackReader(string file, bool JSON)
|
||||
public int MsgPackReader(string file, bool JSON)
|
||||
{
|
||||
int i0 = 0;
|
||||
int i1 = 0;
|
||||
this.Dex = new EXP[0];
|
||||
Header = new PDHead();
|
||||
Header = new Header();
|
||||
|
||||
MsgPack MsgPack = file.ReadMP(JSON);
|
||||
MsgPack MsgPack = file.ReadMPAllAtOnce(JSON);
|
||||
if (!MsgPack.ElementArray("Dex", out MsgPack Dex)) return 0;
|
||||
|
||||
if (MsgPack.Element("Dex", out MsgPack Dex, typeof(object[])))
|
||||
this.Dex = new EXP[Dex.Array.Length];
|
||||
for (i0 = 0; i0 < this.Dex.Length; i0++)
|
||||
{
|
||||
MsgPack Temp = new MsgPack();
|
||||
this.Dex[i0] = new EXP { Name = Dex[i0].ReadString("Name") };
|
||||
|
||||
this.Dex = new EXP[((object[])Dex.Object).Length];
|
||||
MsgPack EXP = new MsgPack();
|
||||
for (i0 = 0; i0 < this.Dex.Length; i0++)
|
||||
if (Dex[i0].GetType() == typeof(MsgPack))
|
||||
{
|
||||
this.Dex[i0] = new EXP();
|
||||
EXP = (MsgPack)Dex[i0];
|
||||
this.Dex[i0].Name = EXP.ReadString("Name");
|
||||
if (EXP.Element("Main", out Temp, typeof(object[])))
|
||||
{
|
||||
this.Dex[i0].Main = new List<EXPElement>
|
||||
{ Capacity = ((object[])Temp.Object).Length };
|
||||
for (i1 = 0; i1 < this.Dex[i0].Main.Capacity; i1++)
|
||||
if (Temp[i1].GetType() == typeof(MsgPack))
|
||||
this.Dex[i0].Main.Add(ReadEXP((MsgPack)Temp[i1]));
|
||||
}
|
||||
if (EXP.Element("Eyes", out Temp, typeof(object[])))
|
||||
{
|
||||
this.Dex[i0].Eyes = new List<EXPElement>
|
||||
{ Capacity = ((object[])Temp.Object).Length };
|
||||
for (i1 = 0; i1 < this.Dex[i0].Eyes.Capacity; i1++)
|
||||
if (Temp[i1].GetType() == typeof(MsgPack))
|
||||
this.Dex[i0].Eyes.Add(ReadEXP((MsgPack)Temp[i1]));
|
||||
}
|
||||
}
|
||||
if (Dex[i0].ElementArray("Main", out MsgPack Main))
|
||||
{
|
||||
this.Dex[i0].Main = new List<EXPElement>();
|
||||
for (i1 = 0; i1 < Main.Array.Length; i1++)
|
||||
this.Dex[i0].Main.Add(EXPElement.Read(Main[i1]));
|
||||
}
|
||||
if (Dex[i0].ElementArray("Eyes", out MsgPack Eyes))
|
||||
{
|
||||
this.Dex[i0].Eyes = new List<EXPElement>();
|
||||
for (i1 = 0; i1 < Eyes.Array.Length; i1++)
|
||||
this.Dex[i0].Eyes.Add(EXPElement.Read(Eyes[i1]));
|
||||
}
|
||||
}
|
||||
MsgPack = null;
|
||||
MsgPack.Dispose();
|
||||
return 1;
|
||||
}
|
||||
|
||||
private EXPElement ReadEXP(MsgPack mp) =>
|
||||
new EXPElement() { Frame = mp.ReadSingle("F"), Both = mp.ReadUInt16("B"),
|
||||
ID = mp.ReadUInt16("I"), Value = mp.ReadSingle("V"),
|
||||
Trans = mp.ReadSingle("T") };
|
||||
|
||||
public void MsgPackWriter(string file, bool JSON)
|
||||
{
|
||||
int i0 = 0;
|
||||
int i1 = 0;
|
||||
MsgPack Dex = new MsgPack("Dex", this.Dex.Length);
|
||||
MsgPack Dex = new MsgPack(this.Dex.Length, "Dex");
|
||||
for (i0 = 0; i0 < this.Dex.Length; i0++)
|
||||
{
|
||||
MsgPack EXP = new MsgPack().Add("Name", this.Dex[i0].Name);
|
||||
MsgPack Main = new MsgPack("Main", this.Dex[i0].Main.Count);
|
||||
MsgPack EXP = MsgPack.New.Add("Name", this.Dex[i0].Name);
|
||||
MsgPack Main = new MsgPack(this.Dex[i0].Main.Count, "Main");
|
||||
for (i1 = 0; i1 < this.Dex[i0].Main.Count; i1++)
|
||||
Main[i1] = WriteEXP(this.Dex[i0].Main[i1]);
|
||||
Main[i1] = this.Dex[i0].Main[i1].Write();
|
||||
EXP.Add(Main);
|
||||
|
||||
MsgPack Eyes = new MsgPack("Eyes", this.Dex[i0].Eyes.Count);
|
||||
MsgPack Eyes = new MsgPack(this.Dex[i0].Eyes.Count, "Eyes");
|
||||
for (i1 = 0; i1 < this.Dex[i0].Eyes.Count; i1++)
|
||||
Eyes[i1] = WriteEXP(this.Dex[i0].Eyes[i1]);
|
||||
Eyes[i1] = this.Dex[i0].Eyes[i1].Write();
|
||||
EXP.Add(Eyes);
|
||||
Dex[i0] = EXP;
|
||||
}
|
||||
@@ -259,10 +223,6 @@ namespace KKdMainLib
|
||||
Dex.Write(true, file, JSON);
|
||||
}
|
||||
|
||||
private MsgPack WriteEXP(EXPElement element) =>
|
||||
new MsgPack().Add("F", element.Frame).Add("B", element.Both ).Add("I", element.ID )
|
||||
.Add("V", element.Value).Add("T", element.Trans);
|
||||
|
||||
public struct EXP
|
||||
{
|
||||
public int MainOffset;
|
||||
@@ -271,6 +231,8 @@ namespace KKdMainLib
|
||||
public string Name;
|
||||
public List<EXPElement> Main;
|
||||
public List<EXPElement> Eyes;
|
||||
|
||||
public override string ToString() => Name;
|
||||
}
|
||||
|
||||
public struct EXPElement
|
||||
@@ -280,6 +242,16 @@ namespace KKdMainLib
|
||||
public ushort ID;
|
||||
public float Value;
|
||||
public float Trans;
|
||||
|
||||
public static EXPElement Read(MsgPack msg) =>
|
||||
new EXPElement() { Frame = msg.ReadSingle("F"), Both = msg.ReadUInt16("B"),
|
||||
ID = msg.ReadUInt16("I"), Value = msg.ReadSingle("V"),
|
||||
Trans = msg.ReadSingle("T"), };
|
||||
|
||||
public MsgPack Write() =>
|
||||
MsgPack.New.Add("F", Frame).Add("B", Both )
|
||||
.Add("I", ID).Add("V", Value)
|
||||
.Add("T", Trans);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+31
-29
@@ -1,5 +1,6 @@
|
||||
using System;
|
||||
using System.Security.Cryptography;
|
||||
using KKdBaseLib;
|
||||
using KKdMainLib.IO;
|
||||
using MSIO = System.IO;
|
||||
|
||||
@@ -7,58 +8,59 @@ namespace KKdMainLib
|
||||
{
|
||||
public static class DIVAFILE
|
||||
{
|
||||
private static readonly byte[] Key = "file access deny".ToASCII();
|
||||
private static readonly byte[] Key = new byte[]
|
||||
{ 0x66, 0x69, 0x6C, 0x65, 0x20, 0x61, 0x63, 0x63,
|
||||
0x65, 0x73, 0x73, 0x20, 0x64, 0x65, 0x6E, 0x79 };
|
||||
|
||||
public static void Decrypt(this string file)
|
||||
{
|
||||
Console.Title = "DIVAFILE Decrypt - File: " + Path.GetFileName(file);
|
||||
Stream reader = File.OpenReader(file);
|
||||
if (reader.ReadInt64() != 0x454C494641564944)
|
||||
{ reader.Close(); return; }
|
||||
int StreamLenght = reader.ReadInt32();
|
||||
int FileLenght = reader.ReadInt32();
|
||||
byte[] decrypted = new byte[StreamLenght];
|
||||
reader.Seek(0, 0);
|
||||
Stream IO = File.OpenReader(file);
|
||||
if (IO.ReadInt64() != 0x454C494641564944)
|
||||
{ IO.Close(); return; }
|
||||
int StreamLength = IO.ReadInt32();
|
||||
int FileLength = IO.ReadInt32();
|
||||
byte[] encrypted = IO.ReadBytes(StreamLength);
|
||||
byte[] decrypted = new byte[StreamLength];
|
||||
IO.Close();
|
||||
|
||||
using (AesManaged crypto = new AesManaged())
|
||||
{
|
||||
crypto.Key = Key; crypto.IV = new byte[16];
|
||||
crypto.Mode = CipherMode.ECB; crypto.Padding = PaddingMode.Zeros;
|
||||
using (CryptoStream cryptoData = new CryptoStream(reader.BaseStream,
|
||||
using (CryptoStream cryptoData = new CryptoStream(new MSIO.MemoryStream(encrypted),
|
||||
crypto.CreateDecryptor(crypto.Key, crypto.IV), CryptoStreamMode.Read))
|
||||
cryptoData.Read(decrypted, 0, StreamLenght);
|
||||
cryptoData.Read(decrypted, 0, StreamLength);
|
||||
}
|
||||
Stream writer = File.OpenWriter(file, FileLenght);
|
||||
for (int i = 0x10; i < StreamLenght && i < FileLenght + 0x10; i++)
|
||||
writer.Write(decrypted[i]);
|
||||
writer.Close();
|
||||
IO = File.OpenWriter(file, FileLength);
|
||||
IO.Write(decrypted, FileLength < StreamLength ? FileLength : StreamLength);
|
||||
IO.Close();
|
||||
}
|
||||
|
||||
public static void Encrypt(this string file)
|
||||
{
|
||||
Console.Title = "DIVAFILE Encrypt - File: " + Path.GetFileName(file);
|
||||
Stream reader = File.OpenReader(file);
|
||||
int FileLenghtOrigin = reader.Length;
|
||||
int FileLenght = FileLenghtOrigin.Align(16);
|
||||
reader.Close();
|
||||
Stream IO = File.OpenReader(file);
|
||||
int FileLengthOrigin = IO.Length;
|
||||
int FileLength = FileLengthOrigin.Align(16);
|
||||
IO.Close();
|
||||
byte[] In = File.OpenReader(file).ToArray(true);
|
||||
byte[] Inalign = new byte[FileLenght];
|
||||
byte[] Inalign = new byte[FileLength];
|
||||
for (int i = 0; i < In.Length; i++) Inalign[i] = In[i];
|
||||
In = null;
|
||||
byte[] encrypted = new byte[FileLenght];
|
||||
byte[] encrypted = new byte[FileLength];
|
||||
using (AesManaged crypto = new AesManaged())
|
||||
{
|
||||
crypto.Key = Key; crypto.IV = new byte[16];
|
||||
crypto.Mode = CipherMode.ECB; crypto.Padding = PaddingMode.Zeros;
|
||||
using (CryptoStream cryptoData = new CryptoStream(new MSIO.MemoryStream(Inalign),
|
||||
crypto.CreateEncryptor(crypto.Key, crypto.IV), CryptoStreamMode.Read))
|
||||
cryptoData.Read(encrypted, 0, FileLenght);
|
||||
cryptoData.Read(encrypted, 0, FileLength);
|
||||
}
|
||||
Stream writer = File.OpenWriter(file, Inalign.Length);
|
||||
writer.Write(0x454C494641564944);
|
||||
writer.Write(FileLenght);
|
||||
writer.Write(FileLenghtOrigin);
|
||||
writer.Write(encrypted);
|
||||
writer.Close();
|
||||
IO = File.OpenWriter(file, Inalign.Length);
|
||||
IO.Write(0x454C494641564944);
|
||||
IO.Write(FileLength);
|
||||
IO.Write(FileLengthOrigin);
|
||||
IO.Write(encrypted);
|
||||
IO.Close();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+284
-189
@@ -1,109 +1,172 @@
|
||||
using System;
|
||||
using System.Net;
|
||||
using System.Xml.Linq;
|
||||
using KKdBaseLib;
|
||||
using KKdMainLib.IO;
|
||||
|
||||
namespace KKdMainLib
|
||||
{
|
||||
public class DataBank
|
||||
{
|
||||
public DataBank()
|
||||
{ Success = false; Xml = null; IO = null; pvList = null; }
|
||||
public DataBank() { Success = false; IO = null; pvList = null; psrDat = null; }
|
||||
|
||||
private Stream IO;
|
||||
private int i;
|
||||
|
||||
private PvList[] pvList;
|
||||
private psrData[] psrDat;
|
||||
|
||||
private const string d = ".";
|
||||
private const string c = ",";
|
||||
|
||||
public bool Success { get; private set; }
|
||||
|
||||
private Xml Xml;
|
||||
private Stream IO;
|
||||
|
||||
private PvList[] pvList;
|
||||
|
||||
public void DBReader(string file)
|
||||
{
|
||||
Success = false;
|
||||
if (!File.Exists(file)) return;
|
||||
string text = File.ReadAllText(file);
|
||||
while (text.Contains("%")) text = WebUtility.UrlDecode(text);
|
||||
string[] array = text.Split(',');
|
||||
|
||||
string out_data = File.ReadAllText(file);
|
||||
while (out_data.Contains("%")) out_data = WebUtility.UrlDecode(out_data);
|
||||
|
||||
string[] data_split = out_data.Split(',');
|
||||
|
||||
if (file.Contains("PvList"))
|
||||
if (file.Contains("psrData") && array.Length % 13 < 2)
|
||||
{
|
||||
if (data_split.Length % 7 < 2)
|
||||
{
|
||||
int Count = data_split.Length / 7;
|
||||
pvList = new PvList[Count];
|
||||
for (int i = 0; i < Count; i++)
|
||||
pvList[i].SetValue(data_split, i);
|
||||
Success = true;
|
||||
return;
|
||||
}
|
||||
psrDat = new psrData[array.Length / 13];
|
||||
for (i = 0; i < psrDat.Length; i++) psrDat[i].SetValue(array, i);
|
||||
Success = true;
|
||||
}
|
||||
else if (file.Contains("psrData")) { psrDat = null; Success = true; }
|
||||
else if (file.Contains("PvList") && array.Length % 7 < 2)
|
||||
{
|
||||
pvList = new PvList[array.Length / 7];
|
||||
for (i = 0; i < pvList.Length; i++) pvList[i].SetValue(array, i);
|
||||
Success = true;
|
||||
}
|
||||
else if (file.Contains("PvList")) { pvList = null; Success = true; }
|
||||
}
|
||||
|
||||
public void DBWriter(string file)
|
||||
{
|
||||
if (!Success) return;
|
||||
|
||||
|
||||
IO = File.OpenWriter();
|
||||
if (file.Contains("PvList"))
|
||||
if (pvList.Length > 0)
|
||||
for (int i = 0; i < pvList.Length; i++)
|
||||
if (file.Contains("psrData"))
|
||||
{
|
||||
if (psrDat != null || psrDat.Length > 0)
|
||||
for (i = 0; i < psrDat.Length; i++)
|
||||
IO.Write(psrDat[i].ToString() + c);
|
||||
}
|
||||
else if (file.Contains("PvList"))
|
||||
{
|
||||
if (pvList != null || pvList.Length > 0)
|
||||
for (i = 0; i < pvList.Length; i++)
|
||||
IO.Write(UrlEncode(pvList[i].ToString() +
|
||||
(i + 1 != pvList.Length ? c : "")));
|
||||
else IO.Write("%2A%2A%2A");
|
||||
(i < pvList.Length ? c : "")));
|
||||
}
|
||||
else IO.Write("%2A%2A%2A");
|
||||
|
||||
|
||||
byte[] data = IO.ToArray(true);
|
||||
|
||||
ushort checksum = DCC.CalculateChecksum(data);
|
||||
uint time = (uint)DateTime.Now.Subtract(new DateTime(1970, 1, 1)).TotalSeconds;
|
||||
|
||||
File.WriteAllBytes(file + "_" + checksum + "_" + time + ".dat", data);
|
||||
ushort num = DCC.CalculateChecksum(data);
|
||||
uint num2 = (uint)DateTime.Now.Subtract(new DateTime(1970, 1, 1)).TotalSeconds;
|
||||
File.WriteAllBytes(file + "_" + num + "_" + num2 + ".dat", data);
|
||||
}
|
||||
|
||||
public void XMLReader(string file)
|
||||
public void MsgPackReader(string file, bool JSON)
|
||||
{
|
||||
Success = false;
|
||||
MsgPack MsgPack = file.ReadMPAllAtOnce(JSON);
|
||||
bool compact = MsgPack.ReadBoolean("Compact");
|
||||
|
||||
if (!File.Exists(file)) return;
|
||||
|
||||
Xml = new Xml();
|
||||
Xml.OpenXml(file, true);
|
||||
|
||||
if (file.Contains("PvList"))
|
||||
foreach (XElement PvList in Xml.doc.Elements("PvList"))
|
||||
if (file.Contains("psrData"))
|
||||
{
|
||||
if (MsgPack.ElementArray("psrData", out MsgPack psrData))
|
||||
{
|
||||
int Count = 0;
|
||||
foreach (XElement PV in PvList.Elements()) if (PV.Name == "PV") Count++;
|
||||
|
||||
pvList = new PvList[Count];
|
||||
int i = 0;
|
||||
foreach (XElement PV in PvList.Elements())
|
||||
{
|
||||
pvList[i].SetValue(PV);
|
||||
i++;
|
||||
}
|
||||
psrDat = new psrData[psrData.Array.Length];
|
||||
for (i = 0; i < psrDat.Length; i++)
|
||||
psrDat[i].SetValue(psrData[i]);
|
||||
}
|
||||
|
||||
Success = true;
|
||||
else if (MsgPack.ContainsKey("psrData")) psrDat = null;
|
||||
Success = true;
|
||||
}
|
||||
else if (file.Contains("PvList"))
|
||||
{
|
||||
if (MsgPack.ElementArray("PvList", out MsgPack PvList))
|
||||
{
|
||||
pvList = new PvList[PvList.Array.Length];
|
||||
for (i = 0; i < pvList.Length; i++)
|
||||
pvList[i].SetValue(PvList[i], compact);
|
||||
}
|
||||
else if (MsgPack.ContainsKey("PvList")) pvList = null;
|
||||
Success = true;
|
||||
}
|
||||
|
||||
MsgPack.Dispose();
|
||||
}
|
||||
|
||||
public void XMLWriter(string file)
|
||||
public void MsgPackWriter(string file, bool JSON, bool Compact = true)
|
||||
{
|
||||
if (!Success) return;
|
||||
MsgPack MsgPack = MsgPack.New;
|
||||
|
||||
Xml = new Xml { Compact = true };
|
||||
|
||||
if (file.Contains("PvList"))
|
||||
if (file.Contains("psrData"))
|
||||
{
|
||||
XElement PvList = new XElement("PvList");
|
||||
foreach (PvList pv in pvList)
|
||||
PvList.Add(pv.WriteXml(Xml, "PV"));
|
||||
Xml.doc.Add(PvList);
|
||||
if (psrDat != null)
|
||||
{
|
||||
MsgPack psrData = new MsgPack(psrDat.Length, "psrData");
|
||||
for (i = 0; i < psrDat.Length; i++) psrData[i] = psrDat[i].WriteMP();
|
||||
MsgPack.Add(psrData);
|
||||
}
|
||||
else MsgPack.Add(new MsgPack("psrData", null));
|
||||
}
|
||||
else if (file.Contains("PvList"))
|
||||
{
|
||||
if (pvList != null)
|
||||
{
|
||||
if (Compact) MsgPack.Add("Compact", Compact);
|
||||
|
||||
MsgPack PvList = new MsgPack(pvList.Length, "PvList");
|
||||
for (i = 0; i < pvList.Length; i++) PvList[i] = pvList[i].WriteMP(Compact);
|
||||
MsgPack.Add(PvList);
|
||||
}
|
||||
else MsgPack.Add(new MsgPack("PvList", null));
|
||||
}
|
||||
MsgPack.Write(file, JSON).Dispose();
|
||||
}
|
||||
|
||||
public static string UrlEncode(string value) =>
|
||||
WebUtility.UrlEncode(value).Replace("+", "%20");
|
||||
|
||||
public struct psrData
|
||||
{
|
||||
public Player p1;
|
||||
public Player p2;
|
||||
public Player p3;
|
||||
public int PV_ID;
|
||||
|
||||
public void SetValue(string[] data, int i = 0)
|
||||
{
|
||||
p1.SetValue(data, i, 0);
|
||||
p2.SetValue(data, i, 1);
|
||||
p3.SetValue(data, i, 2);
|
||||
PV_ID = int.Parse(data[i * 13 + 12]);
|
||||
}
|
||||
|
||||
if (File.Exists(file)) File.Delete(file);
|
||||
Xml.SaveXml(file);
|
||||
public void SetValue(MsgPack msg)
|
||||
{
|
||||
int? ID = msg.ReadNInt32("PV_ID");
|
||||
if (ID != null) PV_ID = (int)ID;
|
||||
else { ID = msg.ReadNInt32("ID"); if (ID != null) PV_ID = (int)ID; }
|
||||
if (msg.Element("P1", out MsgPack P1)) p1.SetValue(P1);
|
||||
if (msg.Element("P2", out MsgPack P2)) p2.SetValue(P2);
|
||||
if (msg.Element("P3", out MsgPack P3)) p3.SetValue(P3);
|
||||
}
|
||||
|
||||
public MsgPack WriteMP() =>
|
||||
MsgPack.New.Add("PV_ID", PV_ID).Add(p1.WriteMP("P1"))
|
||||
.Add(p2.WriteMP("P2")).Add(p3.WriteMP("P3"));
|
||||
|
||||
public override string ToString() =>
|
||||
UrlEncode(p1.ToString() + c + p2.ToString() + c + p3.ToString() + c + PV_ID);
|
||||
}
|
||||
|
||||
public struct Player
|
||||
@@ -112,67 +175,62 @@ namespace KKdMainLib
|
||||
public int Score1;
|
||||
public string Name0;
|
||||
public string Name1;
|
||||
public int Diff;
|
||||
public Difficulty Diff;
|
||||
public bool Has2P => Name1 != null;
|
||||
|
||||
public void SetValue(string[] data, int i = 0, int offset = 0)
|
||||
{
|
||||
string[] arr = data[i * 13 + 0 + offset * 4].Split('.');
|
||||
Score0 = int.Parse(arr[0]);
|
||||
if (arr.Length > 1) Score1 = int.Parse(arr[1]);
|
||||
|
||||
string temp = "";
|
||||
for (int i1 = 0; i1 < data[i * 13 + 1 + offset * 4].Length; i1++)
|
||||
string[] array = data[i * 13 + offset * 4].Split('.');
|
||||
Score0 = int.Parse(array[0]);
|
||||
if (array.Length > 1) Score1 = int.Parse(array[1]);
|
||||
string text = "";
|
||||
for (int j = 0; j < data[i * 13 + 1 + offset * 4].Length; j++)
|
||||
{
|
||||
temp += data[i * 13 + 1 + offset * 4][i1];
|
||||
if (temp.EndsWith("xxx")) { Name0 = temp.Remove(temp.Length - 3); temp = ""; }
|
||||
}
|
||||
if (arr.Length == 1) Name0 = temp;
|
||||
else Name1 = temp;
|
||||
Diff = int.Parse(data[i * 13 + 2 + offset * 4]);
|
||||
}
|
||||
|
||||
public void SetValue(XElement value)
|
||||
{
|
||||
Name1 = null;
|
||||
foreach (XAttribute Entry in value.Attributes())
|
||||
if (Entry.Name == "Score" ) Score0 = int.Parse(Entry.Value);
|
||||
else if (Entry.Name == "Name" ) Name0 = Entry.Value;
|
||||
else if (Entry.Name == "Diff" ) Diff = int.Parse(Entry.Value);
|
||||
else if (Entry.Name == "Score0") Score0 = int.Parse(Entry.Value);
|
||||
else if (Entry.Name == "Score1") Score1 = int.Parse(Entry.Value);
|
||||
else if (Entry.Name == "Name0" ) Name0 = Entry.Value;
|
||||
else if (Entry.Name == "Name1" ) Name1 = Entry.Value;
|
||||
}
|
||||
|
||||
public XElement WriteXml(Xml Xml, string name)
|
||||
{
|
||||
XElement element = new XElement(name);
|
||||
if (!Has2P)
|
||||
{
|
||||
Xml.Writer(element, Score0, "Score");
|
||||
Xml.Writer(element, Name0 , "Name" );
|
||||
text += data[i * 13 + 1 + offset * 4][j].ToString();
|
||||
if (text.EndsWith("xxx"))
|
||||
{
|
||||
Name0 = text.Remove(text.Length - 3);
|
||||
text = "";
|
||||
}
|
||||
}
|
||||
if (array.Length == 1) Name0 = text;
|
||||
else Name1 = text;
|
||||
if (int.TryParse(data[i * 13 + 2 + offset * 4], out int Diff))
|
||||
this.Diff = (Difficulty)Diff;
|
||||
else
|
||||
{
|
||||
Xml.Writer(element, Score0, "Score0");
|
||||
Xml.Writer(element, Score1, "Score1");
|
||||
Xml.Writer(element, Name0 , "Name0" );
|
||||
Xml.Writer(element, Name1 , "Name1" );
|
||||
}
|
||||
Xml.Writer(element, Diff, "Diff");
|
||||
return element;
|
||||
Enum.TryParse(data[i * 13 + 2 + offset * 4], out this.Diff);
|
||||
}
|
||||
|
||||
public override string ToString() => (Score0 + (Has2P ? d + Score1 : "") + c + UrlEncode(Name0) +
|
||||
(Has2P ? "xxx" + UrlEncode(Name1) : "") + c + Diff + c + (Has2P ? "0.1" : "0")).Replace("*", "%2A");
|
||||
}
|
||||
public void SetValue(MsgPack msg)
|
||||
{
|
||||
Diff = (Difficulty)msg.ReadInt32("Diff");
|
||||
Score0 = msg.ReadInt32 ("Score");
|
||||
Name0 = msg.ReadString( "Name");
|
||||
if (Name0 == null)
|
||||
{
|
||||
Score0 = msg.ReadInt32 ("Score0");
|
||||
Score1 = msg.ReadInt32 ("Score1");
|
||||
Name0 = msg.ReadString( "Name0");
|
||||
Name1 = msg.ReadString( "Name1");
|
||||
}
|
||||
else Name1 = null;
|
||||
}
|
||||
|
||||
public static string UrlEncode(string value) => WebUtility.UrlEncode(value).Replace("+", "%20");
|
||||
public MsgPack WriteMP(string name) =>
|
||||
Has2P ? new MsgPack(name).Add("Diff", (int)Diff).Add("Score0", Score0)
|
||||
.Add("Score1", Score1).Add("Name0", Name0).Add("Name1", Name1) :
|
||||
new MsgPack(name).Add("Diff", (int)Diff)
|
||||
.Add("Score" , Score0).Add("Name" , Name0);
|
||||
|
||||
public override string ToString() =>
|
||||
(Score0 + (Has2P ? (d + Score1) : "") + c + UrlEncode(Name0) +
|
||||
(Has2P ? ("xxx" + UrlEncode(Name1)) : "") + c +
|
||||
Diff + c + (Has2P ? "0.1" : "0")).Replace("*", "%2A");
|
||||
}
|
||||
|
||||
public struct PvList
|
||||
{
|
||||
public int ID;
|
||||
public int PV_ID;
|
||||
public bool Enable;
|
||||
public bool Extra;
|
||||
public Date AdvDemoStart;
|
||||
@@ -182,7 +240,7 @@ namespace KKdMainLib
|
||||
|
||||
public void SetValue(string[] data, int i = 0)
|
||||
{
|
||||
ID = int.Parse(data[i * 7 + 0]);
|
||||
PV_ID = int.Parse(data[i * 7]);
|
||||
Enable = int.Parse(data[i * 7 + 1]) == 1;
|
||||
Extra = int.Parse(data[i * 7 + 2]) == 1;
|
||||
AdvDemoStart.SetValue(data[i * 7 + 3]);
|
||||
@@ -191,111 +249,148 @@ namespace KKdMainLib
|
||||
EndShow .SetValue(data[i * 7 + 6]);
|
||||
}
|
||||
|
||||
public override string ToString() => UrlEncode(ID +
|
||||
c + (Enable ? 1 : 0) + c + (Extra ? 1 : 0) +
|
||||
c + AdvDemoStart.ToString() + c + AdvDemoEnd.ToString() +
|
||||
c + StartShow .ToString() + c + EndShow .ToString());
|
||||
|
||||
public void SetValue(XElement Value)
|
||||
public void SetValue(MsgPack msg, bool Compact)
|
||||
{
|
||||
Enable = true;
|
||||
foreach (XAttribute Entry in Value.Attributes())
|
||||
if (Entry.Name == "ID" ) ID = int.Parse(Entry.Value);
|
||||
else if (Entry.Name == "Enable" ) Enable = bool.Parse(Entry.Value);
|
||||
else if (Entry.Name == "Extra" ) Extra = bool.Parse(Entry.Value);
|
||||
MsgPack Temp = MsgPack.New;
|
||||
this.Enable = true;
|
||||
this.Extra = false;
|
||||
|
||||
AdvDemoStart.SetDefaultUpper();
|
||||
AdvDemoEnd .SetDefaultLower();
|
||||
StartShow .SetDefaultLower();
|
||||
EndShow .SetDefaultUpper();
|
||||
|
||||
foreach (XElement value in Value.Elements())
|
||||
if (value.Name == "AdvDemoStart") AdvDemoStart.SetValue(value);
|
||||
else if (value.Name == "AdvDemoEnd" ) AdvDemoEnd .SetValue(value);
|
||||
else if (value.Name == "StartShow" ) StartShow .SetValue(value);
|
||||
else if (value.Name == "EndShow" ) EndShow .SetValue(value);
|
||||
int? ID = msg.ReadNInt32("PV_ID");
|
||||
if (ID != null) PV_ID = (int)ID;
|
||||
else { ID = msg.ReadNInt32("ID"); if (ID != null) PV_ID = (int)ID; }
|
||||
bool? Enable = msg.ReadNBoolean("Enable");
|
||||
bool? Extra = msg.ReadNBoolean("Extra");
|
||||
if (Enable != null) this.Enable = (bool)Enable;
|
||||
if (Extra != null) this.Extra = (bool)Extra ;
|
||||
if (Compact)
|
||||
{
|
||||
AdvDemoStart.SetValue(msg.ReadNInt32("AdvDemoStart"), true);
|
||||
AdvDemoEnd .SetValue(msg.ReadNInt32("AdvDemoEnd" ), false);
|
||||
StartShow .SetValue(msg.ReadNInt32("StartShow" ), false);
|
||||
EndShow .SetValue(msg.ReadNInt32( "EndShow" ), true);
|
||||
return;
|
||||
}
|
||||
if (msg.Element("AdvDemoStart", out Temp)) AdvDemoStart.SetValue(Temp, true);
|
||||
if (msg.Element("AdvDemoEnd" , out Temp)) AdvDemoEnd .SetValue(Temp, false);
|
||||
if (msg.Element("StartShow" , out Temp)) StartShow .SetValue(Temp, false);
|
||||
if (msg.Element( "EndShow" , out Temp)) EndShow .SetValue(Temp, true);
|
||||
}
|
||||
|
||||
public XElement WriteXml(Xml Xml, string name)
|
||||
public MsgPack WriteMP(bool Compact)
|
||||
{
|
||||
XElement element = new XElement(name);
|
||||
Xml.Writer(element, ID , "ID" );
|
||||
if (!Enable) Xml.Writer(element, Enable, "Enable");
|
||||
if ( Extra ) Xml.Writer(element, Extra , "Extra" );
|
||||
if (AdvDemoEnd.WriteLower)
|
||||
element.Add(AdvDemoStart.WriteXml(Xml, "AdvDemoStart"));
|
||||
if (AdvDemoEnd.WriteLower)
|
||||
element.Add(AdvDemoEnd .WriteXml(Xml, "AdvDemoEnd" ));
|
||||
if (StartShow .WriteLower)
|
||||
element.Add(StartShow .WriteXml(Xml, "StartShow" ));
|
||||
if ( EndShow .WriteUpper)
|
||||
element.Add(EndShow .WriteXml(Xml, "EndShow" ));
|
||||
return element;
|
||||
MsgPack MsgPack = MsgPack.New;
|
||||
MsgPack.Add("ID", PV_ID);
|
||||
if (!Enable) MsgPack.Add("Enable", Enable);
|
||||
if ( Extra ) MsgPack.Add("Extra" , Extra );
|
||||
if (Compact)
|
||||
{
|
||||
if (AdvDemoStart.WriteLower) MsgPack.Add("AdvDemoStart", AdvDemoStart.WriteInt());
|
||||
if (AdvDemoEnd .WriteLower) MsgPack.Add("AdvDemoEnd" , AdvDemoEnd .WriteInt());
|
||||
if (StartShow .WriteLower) MsgPack.Add("StartShow" , StartShow .WriteInt());
|
||||
if ( EndShow .WriteUpper) MsgPack.Add( "EndShow" , EndShow .WriteInt());
|
||||
}
|
||||
else
|
||||
{
|
||||
if (AdvDemoStart.WriteLower) MsgPack.Add(AdvDemoStart.WriteMP("AdvDemoStart"));
|
||||
if (AdvDemoEnd .WriteLower) MsgPack.Add(AdvDemoEnd .WriteMP("AdvDemoEnd" ));
|
||||
if (StartShow .WriteLower) MsgPack.Add(StartShow .WriteMP("StartShow" ));
|
||||
if ( EndShow .WriteUpper) MsgPack.Add( EndShow .WriteMP( "EndShow" ));
|
||||
}
|
||||
return MsgPack;
|
||||
}
|
||||
|
||||
public override string ToString() =>
|
||||
UrlEncode(PV_ID + c + (Enable ? 1 : 0) + c + (Extra ? 1 : 0) + c +
|
||||
AdvDemoStart.ToString() + c + AdvDemoEnd.ToString() + c +
|
||||
StartShow.ToString() + c + EndShow.ToString());
|
||||
}
|
||||
|
||||
private const string d = ".";
|
||||
private const string c = ",";
|
||||
|
||||
public struct Date
|
||||
{
|
||||
private int year ;
|
||||
private int year;
|
||||
private int month;
|
||||
private int day ;
|
||||
private int day;
|
||||
|
||||
public int Year { get => year; set { year = value; CheckDate(); } }
|
||||
|
||||
public int Year { get => year ; set { year = value; CheckDate(); } }
|
||||
public int Month { get => month; set { month = value; CheckDate(); } }
|
||||
public int Day { get => day ; set { day = value; CheckDate(); } }
|
||||
|
||||
public bool WriteUpper => (Year == 2029 && Month == 1 && Day == 1) ^ true;
|
||||
public bool WriteLower => (Year == 2000 && Month == 1 && Day == 1) ^ true;
|
||||
public int Day { get => day; set { day = value; CheckDate(); } }
|
||||
|
||||
public void SetDefaultLower() => Year = 1999;
|
||||
public bool WriteUpper => Year != 2029 || Month != 1 || Day != 1;
|
||||
public bool WriteLower => Year != 2000 || Month != 1 || Day != 1;
|
||||
|
||||
public void SetDefaultLower() => Year = 2000;
|
||||
public void SetDefaultUpper() => Year = 2029;
|
||||
|
||||
public void SetValue(string data)
|
||||
{
|
||||
string[] arr = data.Split('-');
|
||||
if (arr.Length != 3) return;
|
||||
Year = int.Parse(arr[0]);
|
||||
Month = int.Parse(arr[1]);
|
||||
Day = int.Parse(arr[2]);
|
||||
string[] array = data.Split('-');
|
||||
if (array.Length == 3)
|
||||
{
|
||||
Year = int.Parse(array[0]);
|
||||
Month = int.Parse(array[1]);
|
||||
Day = int.Parse(array[2]);
|
||||
}
|
||||
}
|
||||
|
||||
public void SetValue(int? YMD, bool SetDefaultUpper)
|
||||
{
|
||||
if (!SetDefaultUpper) SetDefaultLower();
|
||||
else this.SetDefaultUpper();
|
||||
if (YMD != null)
|
||||
{
|
||||
year = YMD.Value / 10000;
|
||||
month = YMD.Value / 100 % 100;
|
||||
day = YMD.Value % 100;
|
||||
CheckDate();
|
||||
}
|
||||
}
|
||||
|
||||
public void SetValue(MsgPack msg, bool SetDefaultUpper)
|
||||
{
|
||||
if (!SetDefaultUpper) SetDefaultLower();
|
||||
else this.SetDefaultUpper();
|
||||
int? Year = msg.ReadNInt32( "Year");
|
||||
int? Month = msg.ReadNInt32("Month");
|
||||
int? Day = msg.ReadNInt32( "Day");
|
||||
if ( Year != null) year = Year.Value;
|
||||
if (Month != null) month = Month.Value;
|
||||
if ( Day != null) day = Day.Value;
|
||||
CheckDate();
|
||||
}
|
||||
|
||||
public int WriteInt() =>
|
||||
(Year * 100 + Month) * 100 + Day;
|
||||
|
||||
public MsgPack WriteMP(string name) =>
|
||||
new MsgPack(name).Add("Year", Year).Add("Month", Month).Add("Day", Day);
|
||||
|
||||
private void CheckDate()
|
||||
{
|
||||
if (year < 2000) { year = 2000; month = 1; day = 1; return; }
|
||||
else if (year >= 2029) { year = 2029; month = 1; day = 1; return; }
|
||||
|
||||
if (month < 1) month = 1;
|
||||
if (year < 2000) { year = 2000; month = 1; day = 1; return; }
|
||||
if (year >= 2029) { year = 2029; month = 1; day = 1; return; }
|
||||
if (month < 1) month = 1;
|
||||
else if (month > 12) month = 12;
|
||||
if (day < 1) day = 1;
|
||||
else if (day > 31 && (month == 1 || month == 3 || month == 5 ||
|
||||
month == 7 || month == 8 || month == 10 || month == 12)) day = 31;
|
||||
else if (day > 30 && (month == 4 || month == 6 || month == 9 || month == 11)) day = 30;
|
||||
else if (day > 29 && month == 2 && year % 4 == 0) day = 29;
|
||||
else if (day > 28 && month == 2 && year % 4 != 0) day = 29;
|
||||
if (day < 1) day = 1;
|
||||
else if (day > 31 && (month == 1 || month == 3 || month == 5 ||
|
||||
month == 7 || month == 8 || month == 10 || month == 12)) day = 31;
|
||||
else if (day > 30 && (month == 4 || month == 6 ||
|
||||
month == 9 || month == 11)) day = 30;
|
||||
else if (day > 29 && month == 2 && year % 4 == 0) day = 29;
|
||||
else if (day > 28 && month == 2 && year % 4 != 0) day = 28;
|
||||
}
|
||||
|
||||
public override string ToString() =>
|
||||
Year.ToString("d4") + "-" + Month.ToString("d2") + "-" + Day.ToString("d2");
|
||||
}
|
||||
|
||||
public void SetValue(XElement value)
|
||||
{
|
||||
foreach (XAttribute Entry in value.Attributes())
|
||||
if (Entry.Name == "Year" ) Year = int.Parse(Entry.Value);
|
||||
else if (Entry.Name == "Month") Month = int.Parse(Entry.Value);
|
||||
else if (Entry.Name == "Day" ) Day = int.Parse(Entry.Value);
|
||||
}
|
||||
|
||||
public XElement WriteXml(Xml Xml, string name)
|
||||
{
|
||||
XElement element = new XElement(name);
|
||||
Xml.Writer(element, Year , "Year" );
|
||||
Xml.Writer(element, Month, "Month");
|
||||
Xml.Writer(element, Day , "Day" );
|
||||
return element;
|
||||
}
|
||||
public enum Difficulty
|
||||
{
|
||||
Easy = 0,
|
||||
Normal = 1,
|
||||
Hard = 2,
|
||||
Extreme = 3,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,253 @@
|
||||
using KKdBaseLib;
|
||||
using KKdBaseLib.F2;
|
||||
using KKdMainLib.IO;
|
||||
|
||||
namespace KKdMainLib
|
||||
{
|
||||
public static class HeaderExtensions
|
||||
{
|
||||
public static Header ReadHeader(this Stream stream, bool Seek, bool ReadSectionSignature = true)
|
||||
{
|
||||
if (Seek)
|
||||
if (stream.LongPosition > 4) stream.LongPosition -= 4;
|
||||
else stream.LongPosition = 0;
|
||||
return stream.ReadHeader(ReadSectionSignature);
|
||||
}
|
||||
|
||||
public static Header ReadHeader(this Stream stream, bool ReadSectionSignature = true)
|
||||
{
|
||||
Header Header = new Header { Format = Format.F2LE, Signature = stream.ReadInt32(),
|
||||
DataSize = stream.ReadInt32(), Length = stream.ReadInt32(), Flags = stream.ReadInt32(),
|
||||
ID = stream.ReadInt32(), SectionSize = stream.ReadInt32(),
|
||||
Mode = stream.ReadInt32() };
|
||||
stream.ReadInt32();
|
||||
if ((Header.Flags & 0x08000000) == 0x08000000) Header.Format = Format.F2BE;
|
||||
Header.NotUseDataSizeAsSectionSize = (Header.Flags & 0x10000000) != 0x10000000;
|
||||
if (Header.Length == 0x40)
|
||||
{
|
||||
stream.ReadInt64();
|
||||
stream.ReadInt64();
|
||||
Header.InnerSignature = stream.ReadInt32();
|
||||
stream.ReadInt32();
|
||||
stream.ReadInt64();
|
||||
}
|
||||
stream.Format = Header.Format;
|
||||
if (ReadSectionSignature) Header.SectionSignature = stream.ReadInt32Endian();
|
||||
return Header;
|
||||
}
|
||||
|
||||
public static void Write(this Stream stream, Header Header, bool Extended = false)
|
||||
{
|
||||
Header.Length = (Header.Format < Format.X && Extended) ? 0x40 : 0x20;
|
||||
Header.Flags = (Header.NotUseDataSizeAsSectionSize ? 0x10000000 : 0) |
|
||||
(Header.Format == Format.F2BE ? 0x08000000 : 0);
|
||||
|
||||
stream.Write(Header.Signature);
|
||||
stream.Write(Header.DataSize);
|
||||
stream.Write(Header.Length);
|
||||
stream.Write(Header.Flags);
|
||||
stream.Write(Header.ID);
|
||||
stream.Write(Header.SectionSize);
|
||||
stream.Write(Header.Mode);
|
||||
stream.Write(0x00);
|
||||
if (Header.Length == 0x40)
|
||||
{
|
||||
stream.Write(Header.Format < Format.MGF ? (int)((Header.SectionSignature ^
|
||||
(Header.DataSize * (long)Header.Signature)) - Header.ID + Header.SectionSize) : 0);
|
||||
stream.Write(0x00);
|
||||
stream.Write(0x00L);
|
||||
stream.Write(Header.InnerSignature);
|
||||
stream.Write(0x00);
|
||||
stream.Write(0x00L);
|
||||
}
|
||||
}
|
||||
|
||||
public static void WriteEOFC(this Stream stream, int ID = 0) =>
|
||||
stream.Write(new Header { ID = ID, Length = 0x20, Signature = 0x43464F45 });
|
||||
}
|
||||
|
||||
public static class POFExtensions
|
||||
{
|
||||
public static void Write(this Stream stream, POF POF, bool ShiftX = false)
|
||||
{
|
||||
byte[] data = POF.Write(POF, ShiftX);
|
||||
Header Header = new Header { ID = POF.ID, Format = Format.F2LE,
|
||||
Length = 0x20, Signature = ShiftX ? 0x31464F50 : 0x30464F50 };
|
||||
Header.DataSize = Header.SectionSize = data.Length;
|
||||
stream.Write(Header);
|
||||
stream.Write(data);
|
||||
if (POF.EOFC) stream.WriteEOFC(POF.ID);
|
||||
}
|
||||
}
|
||||
|
||||
public static class ENRSExtensions
|
||||
{
|
||||
public static void Write(this Stream stream, ENRSList ENRS)
|
||||
{
|
||||
byte[] data = ENRSList.Write(ENRS);
|
||||
Header Header = new Header { ID = ENRS.ID,
|
||||
Format = Format.F2LE, Length = 0x20, Signature = 0x53524E45 };
|
||||
Header.DataSize = Header.SectionSize = data.Length;
|
||||
stream.Write(Header);
|
||||
stream.Write(data);
|
||||
if (ENRS.EOFC) stream.WriteEOFC(ENRS.ID);
|
||||
}
|
||||
}
|
||||
|
||||
public static class StructExtensions
|
||||
{
|
||||
public static Struct ReadStruct(this byte[] Data)
|
||||
{
|
||||
if (Data == null || Data.Length < 1) return default;
|
||||
Struct Struct;
|
||||
using (Stream stream = File.OpenReader(Data))
|
||||
Struct = stream.ReadStruct(stream.ReadHeader(false));
|
||||
return Struct;
|
||||
}
|
||||
|
||||
public static Struct ReadStruct(this Stream stream, Header Header)
|
||||
{
|
||||
Struct Struct = new Struct { Header = Header, DataOffset =
|
||||
stream.Position, Data = stream.ReadBytes(Header.SectionSize) };
|
||||
int ID = Header.ID;
|
||||
|
||||
long Length = stream.Length - stream.Position;
|
||||
long Position = 0;
|
||||
KKdList<Struct> SubStructs = KKdList<Struct>.New;
|
||||
while (Length > Position)
|
||||
{
|
||||
Header = stream.ReadHeader(false);
|
||||
Position += Header.Length + Header.DataSize;
|
||||
if (Header.ID == ID && Header.Signature == 0x43464F45)
|
||||
{ Struct.EOFC = true; break; }
|
||||
else if (Header.ID == 0 && ((Header.Signature & 0xF0FFFFFF) == 0x30464F50 ||
|
||||
Header.Signature == 0x53524E45 || Header.Signature == 0x43505854))
|
||||
SubStructs.Add(new Struct { Header = Header, DataOffset =
|
||||
stream.Position, Data = stream.ReadBytes(Header.SectionSize) });
|
||||
else if (Header.ID <= ID)
|
||||
{ stream.LongPosition -= Header.Length; break; }
|
||||
else SubStructs.Add(stream.ReadStruct(Header));
|
||||
}
|
||||
|
||||
for (int i = 0; i < SubStructs.Capacity; i++)
|
||||
{
|
||||
string Sig = SubStructs[i].Header.ToString();
|
||||
if (Sig == "ENRS" || Sig == "EOFC" || Sig == "POF0" || Sig == "POF1")
|
||||
{
|
||||
if (Sig == "EOFC") Struct.EOFC = true;
|
||||
else if (Sig == "ENRS") Struct.ENRS = ENRSList.Read(SubStructs[i].Data,
|
||||
SubStructs[i].ID, SubStructs[i].EOFC);
|
||||
else Struct.POF = POF .Read(SubStructs[i].Data, Sig == "POF1",
|
||||
SubStructs[i].ID, SubStructs[i].EOFC);
|
||||
SubStructs.RemoveAt(i); SubStructs.Capacity--; i--;
|
||||
}
|
||||
}
|
||||
if (SubStructs.Capacity > 0) Struct.SubStructs = SubStructs.ToArray();
|
||||
return Struct;
|
||||
}
|
||||
|
||||
public static byte[] Write(this Struct Struct, bool ShiftX = false)
|
||||
{
|
||||
byte[] Data;
|
||||
using (Stream stream = File.OpenWriter()) { stream.Write(Struct, ShiftX); Data = stream.ToArray(); }
|
||||
return Data;
|
||||
}
|
||||
|
||||
public static void Write(this Stream stream, Struct Struct, bool ShiftX = false)
|
||||
{
|
||||
int HeaderPosition = stream.Position;
|
||||
stream.Write(Struct.Header);
|
||||
stream.Write(Struct.Data);
|
||||
if (Struct.HasPOF ) stream.Write(Struct.POF , ShiftX);
|
||||
if (Struct.HasENRS) stream.Write(Struct.ENRS);
|
||||
if (Struct.HasSubStructs)
|
||||
for (int i = 0; i < Struct.SubStructs.Length; i++)
|
||||
stream.Write(Struct.SubStructs[i], ShiftX);
|
||||
if (Struct.EOFC) stream.WriteEOFC(Struct.ID);
|
||||
}
|
||||
}
|
||||
|
||||
public static class MPExt
|
||||
{
|
||||
public static MsgPack ReadMP(this byte[] array, bool JSON = false)
|
||||
{
|
||||
MsgPack MsgPack;
|
||||
if (JSON) using (JSON IO = new JSON(File.OpenReader(array))) MsgPack = IO.Read( );
|
||||
else using ( MP IO = new MP(File.OpenReader(array))) MsgPack = IO.Read(true);
|
||||
return MsgPack;
|
||||
}
|
||||
|
||||
public static MsgPack ReadMPAllAtOnce(this string file, bool JSON = false)
|
||||
{
|
||||
MsgPack MsgPack;
|
||||
if (JSON) using (JSON IO = new JSON(File.OpenReader(file + ".json", true))) MsgPack = IO.Read( );
|
||||
else using ( MP IO = new MP(File.OpenReader(file + ".mp" , true))) MsgPack = IO.Read(true);
|
||||
return MsgPack;
|
||||
}
|
||||
|
||||
public static MsgPack ReadMP(this string file, bool JSON = false)
|
||||
{
|
||||
MsgPack MsgPack;
|
||||
if (JSON) using (JSON IO = new JSON(File.OpenReader(file + ".json"))) MsgPack = IO.Read( );
|
||||
else using ( MP IO = new MP(File.OpenReader(file + ".mp" ))) MsgPack = IO.Read(true);
|
||||
return MsgPack;
|
||||
}
|
||||
|
||||
public static void Write(this MsgPack mp, bool Temp, string file, bool JSON = false)
|
||||
{ if (Temp) MsgPack.New.Add(mp).Write(file, JSON).Dispose();
|
||||
else mp .Write(file, JSON); }
|
||||
|
||||
public static MsgPack Write(this MsgPack mp, string file, bool JSON = false)
|
||||
{
|
||||
if (JSON) using (JSON IO = new JSON(File.OpenWriter(file + ".json", true))) IO.Write(mp, "\n", " ");
|
||||
else using ( MP IO = new MP(File.OpenWriter(file + ".json", true))) IO.Write(mp);
|
||||
return mp;
|
||||
}
|
||||
|
||||
public static void WriteAfterAll(this MsgPack mp, bool Temp, string file, bool JSON = false)
|
||||
{ if (Temp) MsgPack.New.Add(mp).WriteAfterAll(file, JSON).Dispose();
|
||||
else mp .WriteAfterAll(file, JSON); }
|
||||
|
||||
public static MsgPack WriteAfterAll(this MsgPack mp, string file, bool JSON = false)
|
||||
{
|
||||
byte[] data = null;
|
||||
if (JSON) using (JSON IO = new JSON(File.OpenWriter())) { IO.Write(mp, true); data = IO.ToArray(); }
|
||||
else using ( MP IO = new MP(File.OpenWriter())) { IO.Write(mp ); data = IO.ToArray(); }
|
||||
File.WriteAllBytes(file + (JSON ? ".json" : ".mp"), data);
|
||||
return mp;
|
||||
}
|
||||
|
||||
public static void ToJSON (this string file) =>
|
||||
file.ReadMP( ).Write(file, true).Dispose();
|
||||
|
||||
public static void ToMsgPack(this string file) =>
|
||||
file.ReadMP(true).Write(file ).Dispose();
|
||||
}
|
||||
|
||||
public static class IKFExt
|
||||
{
|
||||
public static IKF<float, float> Round(this IKF<float, float> KF, int d)
|
||||
{
|
||||
if (KF is KFT0<float, float> KFT0) { KFT0.F = KFT0.F.Round(d); return KFT0; }
|
||||
else if (KF is KFT1<float, float> KFT1) { KFT1.F = KFT1.F.Round(d);
|
||||
KFT1.V = KFT1.V.Round(d); return KFT1; }
|
||||
else if (KF is KFT2<float, float> KFT2) { KFT2.F = KFT2.F.Round(d);
|
||||
KFT2.V = KFT2.V.Round(d); KFT2.T = KFT2.T .Round(d); return KFT2; }
|
||||
else if (KF is KFT3<float, float> KFT3) { KFT3.F = KFT3.F.Round(d);
|
||||
KFT3.V = KFT3.V.Round(d); KFT3.T1 = KFT3.T1.Round(d); KFT3.T2 = KFT3.T2.Round(d); return KFT3; }
|
||||
return KF;
|
||||
}
|
||||
|
||||
public static IKF<double, double> Round(this IKF<double, double> KF, int d)
|
||||
{
|
||||
if (KF is KFT0<double, double> KFT0) { KFT0.F = KFT0.F.Round(d); return KFT0; }
|
||||
else if (KF is KFT1<double, double> KFT1) { KFT1.F = KFT1.F.Round(d);
|
||||
KFT1.V = KFT1.V.Round(d); return KFT1; }
|
||||
else if (KF is KFT2<double, double> KFT2) { KFT2.F = KFT2.F.Round(d);
|
||||
KFT2.V = KFT2.V.Round(d); KFT2.T = KFT2.T .Round(d); return KFT2; }
|
||||
else if (KF is KFT3<double, double> KFT3) { KFT3.F = KFT3.F.Round(d);
|
||||
KFT3.V = KFT3.V.Round(d); KFT3.T1 = KFT3.T1.Round(d); KFT3.T2 = KFT3.T2.Round(d); return KFT3; }
|
||||
return KF;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
using KKdBaseLib;
|
||||
using KKdBaseLib.F2;
|
||||
using KKdMainLib.IO;
|
||||
|
||||
namespace KKdMainLib.F2
|
||||
{
|
||||
public struct Bloom
|
||||
{
|
||||
public CountPointer<BLT> BLTs;
|
||||
private Stream IO;
|
||||
private Header Header;
|
||||
private int i;
|
||||
|
||||
public void BLTReader(string file)
|
||||
{
|
||||
BLTs = default;
|
||||
IO = File.OpenReader(file + ".blt", true);
|
||||
Header = IO.ReadHeader();
|
||||
if (Header.Signature != 0x544D4C42 || Header.InnerSignature != 0x3) return;
|
||||
IO.Position -= 0x4;
|
||||
|
||||
BLTs = IO.ReadCountPointerEndian<BLT>();
|
||||
if (BLTs.Count < 1) { IO.Close(); BLTs.Count = -1; return; }
|
||||
|
||||
if (BLTs.Count > 0 && BLTs.Offset == 0) { IO.Close(); BLTs.Count = -1; return; }
|
||||
/*{
|
||||
IO.Format = Header.Format = Format.X;
|
||||
IO.Offset = Header.Length;
|
||||
IO.Position = BLTs.Offset;
|
||||
BLTs = IO.ReadCountPointerX<BLT>();
|
||||
}*/
|
||||
|
||||
IO.Position = BLTs.Offset;
|
||||
for (i = 0; i < BLTs.Count; i++)
|
||||
{
|
||||
ref BLT BLT = ref BLTs.Entries[i];
|
||||
IO.ReadInt32Endian();
|
||||
BLT.Color .X = IO.ReadSingleEndian();
|
||||
BLT.Color .Y = IO.ReadSingleEndian();
|
||||
BLT.Color .Z = IO.ReadSingleEndian();
|
||||
BLT.Brightpass.X = IO.ReadSingleEndian();
|
||||
BLT.Brightpass.Y = IO.ReadSingleEndian();
|
||||
BLT.Brightpass.Z = IO.ReadSingleEndian();
|
||||
BLT.Range = IO.ReadSingleEndian();
|
||||
}
|
||||
IO.Close();
|
||||
}
|
||||
|
||||
public void TXTWriter(string file)
|
||||
{
|
||||
if (BLTs.Count < 1) return;
|
||||
|
||||
IO = File.OpenWriter();
|
||||
IO.WriteShiftJIS("ID,ColorR,ColorG,ColorB,BrightpassR,BrightpassG,BrightpassB,Range\n");
|
||||
for (i = 0; i < BLTs.Count; i++)
|
||||
IO.Write(i + "," + BLTs[i] + "\n");
|
||||
File.WriteAllBytes(file + "_bloom.txt", IO.ToArray(true));
|
||||
}
|
||||
|
||||
public struct BLT
|
||||
{
|
||||
public Vector3 Color;
|
||||
public Vector3 Brightpass;
|
||||
public float Range;
|
||||
|
||||
public override string ToString() => Color .ToString(6) + "," +
|
||||
Brightpass.ToString(6) + "," +
|
||||
Range .ToString(6);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,79 @@
|
||||
using KKdBaseLib;
|
||||
using KKdBaseLib.F2;
|
||||
using KKdMainLib.IO;
|
||||
|
||||
namespace KKdMainLib.F2
|
||||
{
|
||||
public struct ColorCorrection
|
||||
{
|
||||
public CountPointer<CCT> CCTs;
|
||||
private Stream IO;
|
||||
private Header Header;
|
||||
private int i;
|
||||
|
||||
public void CCTReader(string file)
|
||||
{
|
||||
CCTs = default;
|
||||
IO = File.OpenReader(file + ".cct", true);
|
||||
Header = IO.ReadHeader();
|
||||
if (Header.Signature != 0x54524343 || Header.InnerSignature != 0x3) return;
|
||||
IO.Position -= 0x4;
|
||||
|
||||
CCTs = IO.ReadCountPointerEndian<CCT>();
|
||||
if (CCTs.Count < 1) { IO.Close(); CCTs.Count = -1; return; }
|
||||
|
||||
if (CCTs.Count > 0 && CCTs.Offset == 0) { IO.Close(); CCTs.Count = -1; return; }
|
||||
/*{
|
||||
IO.Format = Header.Format = Format.X;
|
||||
IO.Offset = Header.Length;
|
||||
IO.Position = CCTs.Offset;
|
||||
CCTs = IO.ReadCountPointerX<CCT>();
|
||||
}*/
|
||||
|
||||
IO.Position = CCTs.Offset;
|
||||
for (i = 0; i < CCTs.Count; i++)
|
||||
{
|
||||
ref CCT CCT = ref CCTs.Entries[i];
|
||||
IO.ReadInt32Endian();
|
||||
CCT.Hue = IO.ReadSingleEndian();
|
||||
CCT.Saturation = IO.ReadSingleEndian();
|
||||
CCT.Lightness = IO.ReadSingleEndian();
|
||||
CCT.Exposure = IO.ReadSingleEndian();
|
||||
CCT.Gamma.X = IO.ReadSingleEndian();
|
||||
CCT.Gamma.Y = IO.ReadSingleEndian();
|
||||
CCT.Gamma.Z = IO.ReadSingleEndian();
|
||||
CCT.Contrast = IO.ReadSingleEndian();
|
||||
}
|
||||
|
||||
IO.Close();
|
||||
}
|
||||
|
||||
public void TXTWriter(string file)
|
||||
{
|
||||
if (CCTs.Count < 1) return;
|
||||
|
||||
IO = File.OpenWriter();
|
||||
IO.WriteShiftJIS("ID,Hue,Saturation,Lightness,Exposure,GammaR,GammaG,GammaB,Contrast\n");
|
||||
for (i = 0; i < CCTs.Count; i++)
|
||||
IO.Write(i + "," + CCTs[i] + "\n");
|
||||
File.WriteAllBytes(file + "_cc.txt", IO.ToArray(true));
|
||||
}
|
||||
|
||||
public struct CCT
|
||||
{
|
||||
public float Hue;
|
||||
public float Saturation;
|
||||
public float Lightness;
|
||||
public float Exposure;
|
||||
public Vector3 Gamma;
|
||||
public float Contrast;
|
||||
|
||||
public override string ToString() => Hue .ToString(6) + "," +
|
||||
Saturation.ToString(6) + "," +
|
||||
Lightness .ToString(6) + "," +
|
||||
Exposure .ToString(6) + "," +
|
||||
Gamma .ToString(6) + "," +
|
||||
Contrast .ToString(6);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,75 @@
|
||||
using KKdBaseLib;
|
||||
using KKdBaseLib.F2;
|
||||
using KKdMainLib.IO;
|
||||
|
||||
namespace KKdMainLib.F2
|
||||
{
|
||||
public struct DOF
|
||||
{
|
||||
public CountPointer<DFT> DFTs;
|
||||
private Stream IO;
|
||||
private Header Header;
|
||||
private int i;
|
||||
|
||||
public void DFTReader(string file)
|
||||
{
|
||||
DFTs = default;
|
||||
IO = File.OpenReader(file + ".dft", true);
|
||||
Header = IO.ReadHeader();
|
||||
if (Header.Signature != 0x54464F44 || Header.InnerSignature != 0x3) return;
|
||||
IO.Position -= 0x4;
|
||||
|
||||
DFTs = IO.ReadCountPointerEndian<DFT>();
|
||||
if (DFTs.Count < 1) { IO.Close(); DFTs.Count = -1; return; }
|
||||
|
||||
if (DFTs.Count > 0 && DFTs.Offset == 0) { IO.Close(); DFTs.Count = -1; return; }
|
||||
/*{
|
||||
IO.Format = Header.Format = Format.X;
|
||||
IO.Offset = Header.Length;
|
||||
IO.Position = DFTs.Offset;
|
||||
DFTs = IO.ReadCountPointerX<DFT>();
|
||||
}*/
|
||||
|
||||
IO.Position = DFTs.Offset;
|
||||
for (i = 0; i < DFTs.Count; i++)
|
||||
{
|
||||
ref DFT DFT = ref DFTs.Entries[i];
|
||||
IO.ReadInt32Endian();
|
||||
DFT. Focus = IO.ReadSingleEndian();
|
||||
DFT. FocusRange = IO.ReadSingleEndian();
|
||||
DFT.FuzzingRange = IO.ReadSingleEndian();
|
||||
DFT.Ratio = IO.ReadSingleEndian();
|
||||
DFT.Quality = IO.ReadSingleEndian();
|
||||
if (IO.IsX) IO.ReadInt32();
|
||||
}
|
||||
|
||||
IO.Close();
|
||||
}
|
||||
|
||||
public void TXTWriter(string file)
|
||||
{
|
||||
if (DFTs.Count < 1) return;
|
||||
|
||||
IO = File.OpenWriter();
|
||||
IO.WriteShiftJIS("ID,Focus,FocusRange,FuzzingRange,Ratio,Quality\n");
|
||||
for (i = 0; i < DFTs.Count; i++)
|
||||
IO.Write(i + "," + DFTs[i] + "\n");
|
||||
File.WriteAllBytes(file + "_dof.txt", IO.ToArray(true));
|
||||
}
|
||||
|
||||
public struct DFT
|
||||
{
|
||||
public float Focus;
|
||||
public float FocusRange;
|
||||
public float FuzzingRange;
|
||||
public float Ratio;
|
||||
public float Quality;
|
||||
|
||||
public override string ToString() => Focus .ToString(6) + "," +
|
||||
FocusRange.ToString(6) + "," +
|
||||
FuzzingRange.ToString(6) + "," +
|
||||
Ratio .ToString(6) + "," +
|
||||
Quality .ToString(6);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,137 @@
|
||||
using KKdBaseLib;
|
||||
using KKdBaseLib.F2;
|
||||
using KKdMainLib.IO;
|
||||
|
||||
namespace KKdMainLib.F2
|
||||
{
|
||||
public struct Light
|
||||
{
|
||||
public CountPointer<CountPointer<LIT>> LITs;
|
||||
private Stream IO;
|
||||
private Header Header;
|
||||
private int i, i0;
|
||||
|
||||
public void LITReader(string file)
|
||||
{
|
||||
LITs = default;
|
||||
IO = File.OpenReader(file + ".lit", true);
|
||||
Header = IO.ReadHeader();
|
||||
if (Header.Signature != 0x4354494C || Header.InnerSignature != 0x2 ||
|
||||
Header.SectionSignature != 0x2) return;
|
||||
|
||||
LITs = IO.ReadCountPointerEndian<CountPointer<LIT>>();
|
||||
if (LITs.Count < 1) { IO.Close(); LITs.Count = -1; return; }
|
||||
|
||||
IO.Position = LITs.Offset;
|
||||
for (i = 0; i < LITs.Count; i++)
|
||||
{
|
||||
LITs[i] = IO.ReadCountPointerX<LIT>();
|
||||
if ((LITs[i].Count > 0 || LITs[i].Offset == 0) && !IO.IsX) { IO.Close(); LITs.Count = -1; return; }
|
||||
/*{
|
||||
IO.Format = Header.Format = Format.X;
|
||||
IO.Offset = Header.Length;
|
||||
IO.Position = LITs.Offset;
|
||||
LITs[i] = IO.ReadCountPointerX<LIT>();
|
||||
}
|
||||
if (IO.IsX) IO.ReadInt64();*/
|
||||
}
|
||||
|
||||
for (i = 0; i < LITs.Count; i++)
|
||||
{
|
||||
IO.Position = LITs[i].Offset;
|
||||
for (i0 = 0; i0 < LITs[i].Count; i0++)
|
||||
{
|
||||
ref LIT LIT = ref LITs.Entries[i].Entries[i0];
|
||||
LIT.Id = (Id )IO.ReadInt32Endian();
|
||||
LIT.Flags = (Flags)IO.ReadInt32Endian();
|
||||
LIT.Type = (Type )IO.ReadInt32Endian();
|
||||
if (IO.IsX) { IO.ReadInt64(); IO.ReadInt64(); IO.ReadInt64(); }
|
||||
LIT.Ambient .X = IO.ReadSingleEndian();
|
||||
LIT.Ambient .Y = IO.ReadSingleEndian();
|
||||
LIT.Ambient .Z = IO.ReadSingleEndian();
|
||||
LIT.Ambient .W = IO.ReadSingleEndian();
|
||||
LIT.Diffuse .X = IO.ReadSingleEndian();
|
||||
LIT.Diffuse .Y = IO.ReadSingleEndian();
|
||||
LIT.Diffuse .Z = IO.ReadSingleEndian();
|
||||
LIT.Diffuse .W = IO.ReadSingleEndian();
|
||||
LIT.Specular .X = IO.ReadSingleEndian();
|
||||
LIT.Specular .Y = IO.ReadSingleEndian();
|
||||
LIT.Specular .Z = IO.ReadSingleEndian();
|
||||
LIT.Specular .W = IO.ReadSingleEndian();
|
||||
LIT.Position .X = IO.ReadSingleEndian();
|
||||
LIT.Position .Y = IO.ReadSingleEndian();
|
||||
LIT.Position .Z = IO.ReadSingleEndian();
|
||||
LIT.ToneCurve.X = IO.ReadSingleEndian();
|
||||
LIT.ToneCurve.Y = IO.ReadSingleEndian();
|
||||
LIT.ToneCurve.Z = IO.ReadSingleEndian();
|
||||
if (IO.IsX) { IO.ReadInt64(); IO.ReadInt64(); IO.ReadInt64();
|
||||
IO.ReadInt64(); IO.ReadInt64(); IO.ReadInt32(); }
|
||||
}
|
||||
}
|
||||
IO.Close();
|
||||
}
|
||||
|
||||
public void TXTWriter(string file)
|
||||
{
|
||||
i = 0;
|
||||
if (LITs.Count < 1) return;
|
||||
|
||||
IO = File.OpenWriter();
|
||||
IO.WriteShiftJIS("Type,AmbientR,AmbientG,AmbientB,DiffuseR,DiffuseG,DiffuseB,SpecularR,SpecularG," +
|
||||
"SpecularB,SpecularA,PosX,PosY,PosZ,ToneCurveBegin,ToneCurveEnd,ToneCurveBlendRate," +
|
||||
(file.EndsWith("_chara") ? "コメント" : "ID") + "\n");
|
||||
for (i0 = 0; i0 < LITs[i].Count; i0++)
|
||||
IO.Write(LITs[i][i0] + "," + i + "\n");
|
||||
File.WriteAllBytes(file + "_light.txt", IO.ToArray(true));
|
||||
}
|
||||
|
||||
public struct LIT
|
||||
{
|
||||
public Id Id;
|
||||
public Flags Flags;
|
||||
public Type Type;
|
||||
public Vector4 Ambient;
|
||||
public Vector4 Diffuse;
|
||||
public Vector4 Specular;
|
||||
public Vector3 Position;
|
||||
public Vector3 ToneCurve;
|
||||
|
||||
public override string ToString() => Flags == 0 ? ",,,,,,,,,,,,,,,," : Type + "," +
|
||||
((Flags & Flags.Ambient ) == 0 ? ",,," : Ambient .ToString(6) + ",") +
|
||||
((Flags & Flags.Diffuse ) == 0 ? ",,," : Diffuse .ToString(6) + ",") +
|
||||
((Flags & Flags.Specular ) == 0 ? ",,,," : Specular .ToString(6) + ",") +
|
||||
((Flags & Flags.Position ) == 0 ? ",,," : Position .ToString(6) + ",") +
|
||||
((Flags & Flags.ToneCurve) == 0 ? ",,," : ToneCurve.ToString(6));
|
||||
}
|
||||
|
||||
public enum Id : int
|
||||
{
|
||||
CHARA = 0,
|
||||
STAGE = 1,
|
||||
SUN = 2,
|
||||
REFLECT = 3,
|
||||
SHADOW = 4,
|
||||
CHARA_COLOR = 5,
|
||||
CHARA_F = 6,
|
||||
PROJECTION = 7,
|
||||
}
|
||||
|
||||
public enum Type : int
|
||||
{
|
||||
OFF = 0,
|
||||
PARALLEL = 1,
|
||||
POINT = 2,
|
||||
SPOT = 3,
|
||||
}
|
||||
|
||||
public enum Flags : int
|
||||
{
|
||||
Type = 0b0000000001,
|
||||
Ambient = 0b0000000010,
|
||||
Diffuse = 0b0000000100,
|
||||
Specular = 0b0000001000,
|
||||
Position = 0b0000010000,
|
||||
ToneCurve = 0b1000000000,
|
||||
}
|
||||
}
|
||||
}
|
||||
+217
-231
@@ -1,204 +1,92 @@
|
||||
//Original: https://github.com/blueskythlikesclouds/MikuMikuLibrary/
|
||||
|
||||
using System;
|
||||
using System.IO.Compression;
|
||||
using System.Security.Cryptography;
|
||||
using KKdBaseLib;
|
||||
using KKdMainLib.IO;
|
||||
using MSIO = System.IO;
|
||||
|
||||
namespace KKdMainLib
|
||||
{
|
||||
public class FARC
|
||||
public class FARC : System.IDisposable
|
||||
{
|
||||
public FARC() { Files = new FARCFile[0]; Signature = Farc.FArC; FT = false; }
|
||||
public FARC() => NewFARC();
|
||||
public FARC(string File, bool IsDirectory = false)
|
||||
{ if (IsDirectory) DirectoryPath = File; else FilePath = File; NewFARC(); }
|
||||
|
||||
public FARCFile[] Files = new FARCFile[0];
|
||||
private void NewFARC() { Files = null; Signature = Farc.FArC; CBC = FT = false; }
|
||||
|
||||
public FARCFile[] Files = null;
|
||||
public Type FARCType;
|
||||
public Farc Signature = Farc.FArC;
|
||||
public string FilePath, DirectoryPath;
|
||||
public bool HasFiles => Files == null ? false : Files.Length > 0;
|
||||
|
||||
private bool FT = false;
|
||||
private bool CBC, FT;
|
||||
|
||||
private readonly byte[] Key = Text.ToASCII("project_diva.bin");
|
||||
|
||||
private readonly byte[] KeyFT = { 0x13, 0x72, 0xD5, 0x7B, 0x6E, 0x9E,
|
||||
0x31, 0xEB, 0xA2, 0x39, 0xB8, 0x3C, 0x15, 0x57, 0xC6, 0xBB };
|
||||
|
||||
AesManaged GetAes(bool isFT, byte[] iv)
|
||||
{
|
||||
AesManaged AesManaged = new AesManaged { KeySize = 128, Key = isFT ? KeyFT : Key,
|
||||
AesManaged GetAes(bool isFT, byte[] iv) =>
|
||||
new AesManaged { KeySize = 128, Key = isFT ? KeyFT : Key,
|
||||
BlockSize = 128, Mode = isFT ? CipherMode.CBC : CipherMode.ECB,
|
||||
Padding = PaddingMode.Zeros, IV = iv ?? new byte[16] };
|
||||
return AesManaged;
|
||||
}
|
||||
|
||||
public void UnPack(bool SaveToDisk = true)
|
||||
{ if (HeaderReader()) { FileReader(); if (SaveToDisk) this.SaveToDisk(); } }
|
||||
|
||||
public void UnPack(string file, bool SaveToDisk = true)
|
||||
public bool HeaderReader()
|
||||
{
|
||||
Files = null;
|
||||
Signature = Farc.FArC;
|
||||
FT = false;
|
||||
Console.Title = "FARC Extractor - Archive: " + Path.GetFileName(file);
|
||||
if (!File.Exists(file))
|
||||
{
|
||||
Console.WriteLine("File {0} doesn't exist.", Path.GetFileName(file));
|
||||
Console.Clear();
|
||||
return;
|
||||
}
|
||||
NewFARC();
|
||||
if (!File.Exists(FilePath)) return false;
|
||||
|
||||
Stream reader = File.OpenReader(file);
|
||||
string directory = Path.GetFullPath(file).Replace(Path.GetExtension(file), "");
|
||||
Stream reader = File.OpenReader(FilePath);
|
||||
DirectoryPath = Path.GetFullPath(FilePath).Replace(Path.GetExtension(FilePath), "");
|
||||
Signature = (Farc)reader.ReadInt32Endian(true);
|
||||
if (Signature != Farc.FArc && Signature != Farc.FArC && Signature != Farc.FARC)
|
||||
{
|
||||
Console.WriteLine("Unknown signature"); reader.Close();
|
||||
Console.Clear();
|
||||
return;
|
||||
}
|
||||
{ reader.Close(); return false; }
|
||||
|
||||
MSIO.Directory.CreateDirectory(directory);
|
||||
int HeaderLength = reader.ReadInt32Endian(true);
|
||||
if (Signature != Farc.FARC)
|
||||
if (Signature == Farc.FARC)
|
||||
{
|
||||
reader.ReadUInt32();
|
||||
HeaderReader(HeaderLength, ref Files, ref reader);
|
||||
reader.Close();
|
||||
FARCType = (Type)reader.ReadInt32Endian(true);
|
||||
reader.ReadInt32();
|
||||
|
||||
for (int i = 0; i < Files.Length; i++)
|
||||
int FARCMode = reader.ReadInt32Endian(true);
|
||||
FT = FARCMode == 0x10;
|
||||
CBC = FARCMode != 0x10 && FARCMode != 0x40;
|
||||
|
||||
if (CBC && FARCType.HasFlag(Type.ECB))
|
||||
{
|
||||
if (Signature == Farc.FArC)
|
||||
using (MSIO.MemoryStream memorystream = new MSIO.MemoryStream(
|
||||
File.ReadAllBytes(file, Files[i].SizeComp, Files[i].Offset)))
|
||||
{
|
||||
GZipStream gZipStream = new GZipStream(memorystream, CompressionMode.Decompress);
|
||||
Files[i].Data = new byte[Files[i].SizeUnc];
|
||||
gZipStream.Read(Files[i].Data, 0, Files[i].SizeUnc);
|
||||
}
|
||||
else
|
||||
Files[i].Data = File.ReadAllBytes(file, Files[i].SizeUnc, Files[i].Offset);
|
||||
reader.Close();
|
||||
byte[] Header = new byte[HeaderLength - 0x08];
|
||||
MSIO.FileStream stream = new MSIO.FileStream(FilePath, MSIO.FileMode.Open,
|
||||
MSIO.FileAccess.ReadWrite, MSIO.FileShare.ReadWrite) { Position = 0x10 };
|
||||
|
||||
if (SaveToDisk)
|
||||
{
|
||||
File.WriteAllBytes(Path.Combine(directory, Files[i].Name), Files[i].Data);
|
||||
Files[i].Data = null;
|
||||
}
|
||||
using (AesManaged aes = GetAes(true, null))
|
||||
using (CryptoStream cryptoStream = new CryptoStream(stream,
|
||||
aes.CreateDecryptor(), CryptoStreamMode.Read))
|
||||
cryptoStream.Read(Header, 0x00, HeaderLength - 0x08);
|
||||
Header = SkipData(Header, 0x10);
|
||||
reader = File.OpenReader(Header);
|
||||
|
||||
FARCMode = reader.ReadInt32Endian(true);
|
||||
FT = FARCMode == 0x10;
|
||||
}
|
||||
Console.Clear();
|
||||
return;
|
||||
}
|
||||
|
||||
int Mode = reader.ReadInt32Endian(true);
|
||||
reader.ReadUInt32();
|
||||
bool GZip = (Mode & 2) == 2;
|
||||
bool ECB = (Mode & 4) == 4;
|
||||
|
||||
int FARCType = reader.ReadInt32Endian(true);
|
||||
FT = FARCType == 0x10;
|
||||
bool CBC = !FT && FARCType != 0x40;
|
||||
if (ECB && CBC)
|
||||
{
|
||||
byte[] Header = new byte[HeaderLength - 0x08];
|
||||
FT = true;
|
||||
reader.Close();
|
||||
MSIO.FileStream stream = new MSIO.FileStream(file, MSIO.FileMode.Open,
|
||||
MSIO.FileAccess.ReadWrite, MSIO.FileShare.ReadWrite);
|
||||
stream.Seek(0x10, 0);
|
||||
|
||||
using (CryptoStream cryptoStream = new CryptoStream(stream,
|
||||
GetAes(true, null).CreateDecryptor(), CryptoStreamMode.Read))
|
||||
cryptoStream.Read(Header, 0x00, HeaderLength - 0x08);
|
||||
Header = SkipData(Header, 0x10);
|
||||
Stream CBCreader = new Stream(new MSIO.MemoryStream(Header));
|
||||
CBCreader.BaseStream.Seek(0, 0);
|
||||
|
||||
FARCType = CBCreader.ReadInt32Endian(true);
|
||||
FT = FARCType == 0x10;
|
||||
if (CBCreader.ReadInt32Endian(true) == 1)
|
||||
Files = new FARCFile[CBCreader.ReadInt32Endian(true)];
|
||||
CBCreader.ReadUInt32();
|
||||
HeaderReader(HeaderLength, ref Files, ref CBCreader);
|
||||
CBCreader.Close();
|
||||
}
|
||||
else
|
||||
{
|
||||
if (Signature == Farc.FARC)
|
||||
if (reader.ReadInt32Endian(true) == 1)
|
||||
Files = new FARCFile[reader.ReadInt32Endian(true)];
|
||||
reader.ReadUInt32();
|
||||
HeaderReader(HeaderLength, ref Files, ref reader);
|
||||
reader.Close();
|
||||
}
|
||||
reader.ReadInt32();
|
||||
|
||||
for (int i = 0; i < Files.Length; i++)
|
||||
{
|
||||
int FileSize = ECB || Files[i].ECB ? Files[i].SizeComp.Align(0x10) : Files[i].SizeComp;
|
||||
MSIO.FileStream stream = new MSIO.FileStream(file, MSIO.FileMode.Open,
|
||||
MSIO.FileAccess.ReadWrite, MSIO.FileShare.ReadWrite);
|
||||
stream.Seek(Files[i].Offset, 0);
|
||||
Files[i].Data = new byte[FileSize];
|
||||
|
||||
bool Encrypted = false;
|
||||
if (ECB)
|
||||
{
|
||||
if ((FT && Files[i].ECB) || CBC)
|
||||
{
|
||||
using (CryptoStream cryptoStream = new CryptoStream(stream,
|
||||
GetAes(true, null).CreateDecryptor(), CryptoStreamMode.Read))
|
||||
cryptoStream.Read(Files[i].Data, 0, FileSize);
|
||||
Files[i].Data = SkipData(Files[i].Data, 0x10);
|
||||
}
|
||||
else
|
||||
using (CryptoStream cryptoStream = new CryptoStream(stream,
|
||||
GetAes(false, null).CreateDecryptor(), CryptoStreamMode.Read))
|
||||
cryptoStream.Read(Files[i].Data, 0, FileSize);
|
||||
Encrypted = true;
|
||||
}
|
||||
|
||||
bool Compressed = false;
|
||||
bool LocalGZip = (FT && Files[i].GZip) || GZip && Files[i].SizeUnc != 0;
|
||||
if (LocalGZip)
|
||||
{
|
||||
GZipStream gZipStream;
|
||||
if (Encrypted)
|
||||
{
|
||||
gZipStream = new GZipStream(new MSIO.MemoryStream(
|
||||
Files[i].Data), CompressionMode.Decompress);
|
||||
stream.Close();
|
||||
}
|
||||
else gZipStream = new GZipStream(stream, CompressionMode.Decompress);
|
||||
Files[i].Data = new byte[Files[i].SizeUnc];
|
||||
gZipStream.Read(Files[i].Data, 0, Files[i].SizeUnc);
|
||||
|
||||
Compressed = true;
|
||||
}
|
||||
|
||||
if (!Encrypted && !Compressed)
|
||||
{
|
||||
Files[i].Data = new byte[Files[i].SizeUnc];
|
||||
stream.Read(Files[i].Data, 0, Files[i].SizeUnc);
|
||||
stream.Close();
|
||||
}
|
||||
|
||||
if (SaveToDisk)
|
||||
{
|
||||
File.WriteAllBytes(Path.Combine(directory, Files[i].Name), Files[i].Data);
|
||||
Files[i].Data = null;
|
||||
}
|
||||
|
||||
}
|
||||
Console.Clear();
|
||||
}
|
||||
|
||||
byte[] SkipData(byte[] Data, int Skip)
|
||||
{
|
||||
byte[] SkipData = new byte[Data.Length - Skip];
|
||||
for (int i = 0; i < Data.Length - Skip; i++) SkipData[i] = Data[i + Skip];
|
||||
return SkipData;
|
||||
}
|
||||
|
||||
void HeaderReader(int HeaderLenght, ref FARCFile[] Files, ref Stream reader)
|
||||
{
|
||||
if (Files == null)
|
||||
{
|
||||
int Count = 0;
|
||||
long Position = reader.BaseStream.Position;
|
||||
while (reader.BaseStream.Position < HeaderLenght)
|
||||
long Position = reader.LongPosition;
|
||||
while (reader.LongPosition < HeaderLength)
|
||||
{
|
||||
reader.NullTerminated();
|
||||
reader.ReadInt32();
|
||||
@@ -207,11 +95,10 @@ namespace KKdMainLib
|
||||
if (Signature == Farc.FARC && FT) reader.ReadInt32();
|
||||
Count++;
|
||||
}
|
||||
reader.Seek(Position, 0);
|
||||
reader.LongPosition = Position;
|
||||
Files = new FARCFile[Count];
|
||||
}
|
||||
|
||||
int LocalMode = 0;
|
||||
for (int i = 0; i < Files.Length; i++)
|
||||
{
|
||||
Files[i].Name = reader.NullTerminatedUTF8();
|
||||
@@ -219,61 +106,152 @@ namespace KKdMainLib
|
||||
if (Signature != Farc.FArc) Files[i].SizeComp = reader.ReadInt32Endian(true);
|
||||
Files[i].SizeUnc = reader.ReadInt32Endian(true);
|
||||
if (Signature == Farc.FARC && FT)
|
||||
Files[i].Type = (Type)reader.ReadInt32Endian(true);
|
||||
}
|
||||
|
||||
reader.Close();
|
||||
return true;
|
||||
}
|
||||
|
||||
private void FileReader()
|
||||
{ for (int i = 0; i < Files.Length; i++) FileReader(i); }
|
||||
|
||||
public byte[] FileReader(int i)
|
||||
{
|
||||
if (!HasFiles) return null;
|
||||
if (i >= Files.Length) return null;
|
||||
if (Signature != Farc.FARC)
|
||||
{
|
||||
if (Signature == Farc.FArC)
|
||||
using (MSIO.MemoryStream memorystream = new MSIO.MemoryStream(
|
||||
File.ReadAllBytes(FilePath, Files[i].SizeComp, Files[i].Offset)))
|
||||
using (GZipStream gZipStream = new GZipStream(memorystream, CompressionMode.Decompress))
|
||||
{
|
||||
Files[i].Data = new byte[Files[i].SizeUnc];
|
||||
gZipStream.Read(Files[i].Data, 0, Files[i].SizeUnc);
|
||||
}
|
||||
else Files[i].Data = File.ReadAllBytes(FilePath, Files[i].SizeUnc, Files[i].Offset);
|
||||
return Files[i].Data;
|
||||
}
|
||||
|
||||
int FileSize = FARCType.HasFlag(Type.ECB) || Files[i].Type.HasFlag(Type.ECB) ?
|
||||
Files[i].SizeComp.Align(0x10) : Files[i].SizeComp;
|
||||
MSIO.FileStream stream = new MSIO.FileStream(FilePath, MSIO.FileMode.Open,
|
||||
MSIO.FileAccess.ReadWrite, MSIO.FileShare.ReadWrite);
|
||||
stream.Seek(Files[i].Offset, 0);
|
||||
Files[i].Data = new byte[FileSize];
|
||||
|
||||
bool Encrypted = false;
|
||||
if (FARCType.HasFlag(Type.ECB))
|
||||
{
|
||||
if ((FT && Files[i].Type.HasFlag(Type.ECB)) || CBC)
|
||||
{
|
||||
LocalMode = reader.ReadInt32Endian(true);
|
||||
Files[i].GZip = (LocalMode & 2) == 2;
|
||||
Files[i].ECB = (LocalMode & 4) == 4;
|
||||
using (AesManaged aes = GetAes(true, null))
|
||||
using (CryptoStream cryptoStream = new CryptoStream(stream,
|
||||
aes.CreateDecryptor(), CryptoStreamMode.Read))
|
||||
cryptoStream.Read(Files[i].Data, 0, FileSize);
|
||||
Files[i].Data = SkipData(Files[i].Data, 0x10);
|
||||
}
|
||||
else
|
||||
using (AesManaged aes = GetAes(false, null))
|
||||
using (CryptoStream cryptoStream = new CryptoStream(stream,
|
||||
aes.CreateDecryptor(), CryptoStreamMode.Read))
|
||||
cryptoStream.Read(Files[i].Data, 0, FileSize);
|
||||
Encrypted = true;
|
||||
}
|
||||
|
||||
bool Compressed = false;
|
||||
if (((FT && Files[i].Type.HasFlag(Type.GZip)) ||
|
||||
FARCType.HasFlag(Type.GZip)) && Files[i].SizeUnc > 0)
|
||||
{
|
||||
GZipStream gZipStream = new GZipStream(Encrypted ? new MSIO.MemoryStream(Files[i].Data) :
|
||||
(MSIO.Stream)stream, CompressionMode.Decompress);
|
||||
byte[] Temp = new byte[Files[i].SizeUnc];
|
||||
gZipStream.Read(Temp, 0, Files[i].SizeUnc);
|
||||
Files[i].Data = Temp;
|
||||
gZipStream.Dispose();
|
||||
Compressed = true;
|
||||
}
|
||||
|
||||
if (!Encrypted && !Compressed)
|
||||
{
|
||||
Files[i].Data = new byte[Files[i].SizeUnc];
|
||||
stream.Read(Files[i].Data, 0, Files[i].SizeUnc);
|
||||
}
|
||||
stream.Dispose();
|
||||
return Files[i].Data;
|
||||
}
|
||||
|
||||
private void SaveToDisk()
|
||||
{
|
||||
if (DirectoryPath == null || Files == null) return;
|
||||
if (DirectoryPath == "" || Files.Length < 1) return;
|
||||
MSIO.Directory.CreateDirectory(DirectoryPath);
|
||||
for (int i = 0; i < Files.Length; i++)
|
||||
{
|
||||
if (Files[i].Data != null)
|
||||
File.WriteAllBytes(Path.Combine(DirectoryPath, Files[i].Name), Files[i].Data);
|
||||
Files[i].Data = null;
|
||||
}
|
||||
}
|
||||
|
||||
public void Pack(string file)
|
||||
private byte[] SkipData(byte[] Data, int Skip)
|
||||
{
|
||||
Files = null;
|
||||
FT = false;
|
||||
string[] files = Directory.GetFiles(file);
|
||||
byte[] SkipData = new byte[Data.Length - Skip];
|
||||
for (int i = 0; i < Data.Length - Skip; i++) SkipData[i] = Data[i + Skip];
|
||||
return SkipData;
|
||||
}
|
||||
|
||||
public void Pack(Farc Signature = Farc.FArC)
|
||||
{
|
||||
NewFARC();
|
||||
string[] files = Directory.GetFiles(DirectoryPath);
|
||||
Files = new FARCFile[files.Length];
|
||||
|
||||
for (int i = 0; i < files.Length; i++)
|
||||
{
|
||||
Files[i] = new FARCFile { Name = files[i] };
|
||||
string ext = Path.GetExtension(files[i]).ToLower();
|
||||
if (ext == ".a3da" || ext == ".diva" || ext == ".vag")
|
||||
Signature = Farc.FArc;
|
||||
}
|
||||
Files[i] = new FARCFile { Name = Path.GetFileName(files[i]), Data = File.ReadAllBytes(files[i]) };
|
||||
files = null;
|
||||
this.Signature = Signature;
|
||||
Save();
|
||||
}
|
||||
|
||||
Stream writer = File.OpenWriter(file + ".farc", true);
|
||||
public void Save()
|
||||
{
|
||||
for (int i = 0; i < Files.Length; i++)
|
||||
{
|
||||
string ext = Path.GetExtension(Files[i].Name).ToLower();
|
||||
if (ext == ".a3da" || ext == ".diva" || ext == ".vag")
|
||||
{ Signature = Farc.FArc; break; }
|
||||
}
|
||||
|
||||
Stream writer = File.OpenWriter(DirectoryPath + ".farc", true);
|
||||
writer.WriteEndian((int)Signature, true);
|
||||
|
||||
Stream HeaderWriter = File.OpenWriter();
|
||||
for (int i = 0; i < 3; i++) HeaderWriter.WriteByte(0x00);
|
||||
if (Signature == Farc.FArc) HeaderWriter.WriteByte(0x20);
|
||||
else if (Signature == Farc.FArC) HeaderWriter.WriteByte(0x10);
|
||||
else if (Signature == Farc.FARC)
|
||||
using (Stream HeaderWriter = File.OpenWriter())
|
||||
{
|
||||
HeaderWriter.WriteByte(0x06);
|
||||
for (int i = 0; i < 7; i++) HeaderWriter.WriteByte(0x00);
|
||||
HeaderWriter.WriteByte(0x40);
|
||||
for (int i = 0; i < 8; i++) HeaderWriter.WriteByte(0x00);
|
||||
if (Signature == Farc.FArc) HeaderWriter.WriteEndian(0x20, true);
|
||||
else if (Signature == Farc.FArC) HeaderWriter.WriteEndian(0x10, true);
|
||||
else if (Signature == Farc.FARC)
|
||||
{
|
||||
HeaderWriter.WriteEndian((int)FARCType, true);
|
||||
HeaderWriter.Write (0x00);
|
||||
HeaderWriter.WriteEndian(0x40, true);
|
||||
HeaderWriter.Write (0x00);
|
||||
}
|
||||
int HeaderPartLength = Signature == Farc.FArc ? 0x09 : 0x0D;
|
||||
for (int i = 0; i < Files.Length; i++)
|
||||
HeaderWriter.Length += Path.GetFileName(Files[i].Name).Length + HeaderPartLength;
|
||||
writer.WriteEndian(HeaderWriter.Length, true);
|
||||
writer.Write(HeaderWriter.ToArray(true));
|
||||
}
|
||||
int HeaderPartLength = Signature == Farc.FArc ? 0x09 : 0x0D;
|
||||
for (int i = 0; i < Files.Length; i++)
|
||||
HeaderWriter.Length += Path.GetFileName(Files[i].Name).Length + HeaderPartLength;
|
||||
writer.WriteEndian(HeaderWriter.Length, true);
|
||||
writer.Write(HeaderWriter.ToArray(true));
|
||||
HeaderWriter = null;
|
||||
|
||||
int Align = writer.Position.Align(0x10) - writer.Position;
|
||||
for (int i1 = 0; i1 < Align; i1++)
|
||||
if (Signature == Farc.FArc) writer.WriteByte(0x00);
|
||||
else writer.WriteByte(0x78);
|
||||
writer.WriteByte((byte)(Signature == Farc.FArc ? 0x00 : 0x78));
|
||||
|
||||
for (int i = 0; i < Files.Length; i++)
|
||||
CompressStuff(i, ref Files, ref writer);
|
||||
|
||||
if (Signature == Farc.FARC) writer.Seek(0x1C, 0);
|
||||
else writer.Seek(0x0C, 0);
|
||||
writer.Position = Signature == Farc.FARC ? 0x1C : 0x0C;
|
||||
for (int i = 0; i < Files.Length; i++)
|
||||
{
|
||||
writer.Write(Path.GetFileName(Files[i].Name) + "\0");
|
||||
@@ -285,35 +263,33 @@ namespace KKdMainLib
|
||||
writer.Close();
|
||||
}
|
||||
|
||||
void CompressStuff(int i, ref FARCFile[] Files, ref Stream writer)
|
||||
private void CompressStuff(int i, ref FARCFile[] Files, ref Stream writer)
|
||||
{
|
||||
Files[i].Offset = writer.Position;
|
||||
Files[i].Data = File.ReadAllBytes(Files[i].Name);
|
||||
Files[i].SizeUnc = Files[i].Data.Length;
|
||||
Files[i].Type = Type.None;
|
||||
|
||||
if (Signature != Farc.FArc)
|
||||
if (Signature == Farc.FArC || (Signature == Farc.FARC && FARCType.HasFlag(Type.GZip)))
|
||||
{
|
||||
if (Signature != Farc.FArc)
|
||||
{
|
||||
MSIO.MemoryStream stream = new MSIO.MemoryStream();
|
||||
using (GZipStream gZipStream = new GZipStream(stream, CompressionMode.Compress))
|
||||
gZipStream.Write(Files[i].Data, 0, Files[i].Data.Length);
|
||||
Files[i].Data = stream.ToArray();
|
||||
stream.Dispose();
|
||||
Files[i].SizeComp = Files[i].Data.Length;
|
||||
}
|
||||
else if (Signature == Farc.FARC)
|
||||
{
|
||||
int AlignData = Files[i].Data.Length.Align(0x40);
|
||||
byte[] Data = new byte[AlignData];
|
||||
for (int i1 = 0; i1 < Files[i].Data.Length; i1++)
|
||||
Data[i1] = Files[i].Data[i1];
|
||||
for (int i1 = Files[i].Data.Length; i1 < AlignData; i1++)
|
||||
Data[i1] = 0x78;
|
||||
|
||||
Files[i].Data = Encrypt(Data, false);
|
||||
}
|
||||
Files[i].Type |= Type.GZip;
|
||||
MSIO.MemoryStream stream = new MSIO.MemoryStream();
|
||||
using (GZipStream gZipStream = new GZipStream(stream, CompressionMode.Compress))
|
||||
gZipStream.Write(Files[i].Data, 0, Files[i].Data.Length);
|
||||
Files[i].Data = stream.ToArray();
|
||||
stream.Dispose();
|
||||
Files[i].SizeComp = Files[i].Data.Length;
|
||||
}
|
||||
|
||||
if (Signature == Farc.FARC && FARCType.HasFlag(Type.ECB))
|
||||
{
|
||||
int AlignData = Files[i].Data.Length.Align(0x40);
|
||||
byte[] Data = new byte[AlignData];
|
||||
for (int i1 = 0; i1 < AlignData ; i1++) Data[i1] = 0x78;
|
||||
for (int i1 = 0; i1 < Files[i].Data.Length; i1++) Data[i1] = Files[i].Data[i1];
|
||||
|
||||
Files[i].Data = Encrypt(Data, false);
|
||||
}
|
||||
|
||||
writer.Write(Files[i].Data);
|
||||
Files[i].Data = null;
|
||||
|
||||
@@ -321,36 +297,46 @@ namespace KKdMainLib
|
||||
{
|
||||
int Align = writer.Position.Align(0x20) - writer.Position;
|
||||
for (int i1 = 0; i1 < Align; i1++)
|
||||
if (Signature == Farc.FArc) writer.WriteByte(0x00);
|
||||
else writer.WriteByte(0x78);
|
||||
writer.WriteByte((byte)(Signature == Farc.FArc ? 0x00 : 0x78));
|
||||
}
|
||||
}
|
||||
|
||||
byte[] Encrypt(byte[] Data, bool isFT)
|
||||
private byte[] Encrypt(byte[] Data, bool isFT)
|
||||
{
|
||||
MSIO.MemoryStream stream = new MSIO.MemoryStream();
|
||||
using (AesManaged aes = GetAes(isFT, null))
|
||||
using (CryptoStream cryptoStream = new CryptoStream(stream,
|
||||
GetAes(isFT, null).CreateEncryptor(),CryptoStreamMode.Write))
|
||||
aes.CreateEncryptor(), CryptoStreamMode.Write))
|
||||
cryptoStream.Write(Data, 0, Data.Length);
|
||||
return stream.ToArray();
|
||||
}
|
||||
|
||||
public enum Farc
|
||||
{
|
||||
FArc = 0x46417263,
|
||||
FArC = 0x46417243,
|
||||
FARC = 0x46415243,
|
||||
}
|
||||
public void Dispose() => NewFARC();
|
||||
|
||||
public struct FARCFile
|
||||
{
|
||||
public int Offset;
|
||||
public int SizeComp;
|
||||
public int SizeUnc;
|
||||
public bool GZip;
|
||||
public bool ECB;
|
||||
public Type Type;
|
||||
public byte[] Data;
|
||||
public string Name;
|
||||
|
||||
public override string ToString() => Name;
|
||||
}
|
||||
|
||||
public enum Farc : int
|
||||
{
|
||||
FArc = 0x46417263,
|
||||
FArC = 0x46417243,
|
||||
FARC = 0x46415243,
|
||||
}
|
||||
|
||||
public enum Type : int
|
||||
{
|
||||
None = 0b000,
|
||||
GZip = 0b010,
|
||||
ECB = 0b100,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,5 +1,4 @@
|
||||
using System;
|
||||
using MSIO = System.IO;
|
||||
using MSIO = System.IO;
|
||||
|
||||
namespace KKdMainLib.IO
|
||||
{
|
||||
|
||||
@@ -0,0 +1,150 @@
|
||||
using KKdBaseLib;
|
||||
using KKdBaseLib.F2;
|
||||
|
||||
namespace KKdMainLib.IO
|
||||
{
|
||||
public static class Extensions
|
||||
{
|
||||
public static string NullTerminatedASCII(this Stream stream, byte End = 0) =>
|
||||
stream.NullTerminated(End).ToASCII();
|
||||
public static string NullTerminatedUTF8 (this Stream stream, byte End = 0) =>
|
||||
stream.NullTerminated(End).ToUTF8 ();
|
||||
public static byte[] NullTerminated (this Stream stream, byte End = 0)
|
||||
{
|
||||
KKdList<byte> s = KKdList<byte>.New;
|
||||
while (stream.LongPosition < stream.LongLength)
|
||||
{
|
||||
byte a = stream.ReadByte();
|
||||
if (a == End) break;
|
||||
else s.Add(a);
|
||||
}
|
||||
return s.ToArray();
|
||||
}
|
||||
|
||||
public static byte PeekByte (this Stream stream)
|
||||
{ byte val = stream.ReadByte(); stream.LongPosition--; return val; }
|
||||
public static char PeekCharASCII(this Stream stream)
|
||||
{ byte val = stream.ReadByte(); stream.LongPosition--; return (char)val; }
|
||||
public static char PeekCharUTF8 (this Stream stream)
|
||||
{ long LongPosition = stream.LongPosition; char val = stream.ReadCharUTF8();
|
||||
stream.LongPosition = LongPosition; return val; }
|
||||
|
||||
public static Stream SkipWhitespace(this Stream stream)
|
||||
{
|
||||
while (true)
|
||||
if (char.IsWhiteSpace(stream.PeekCharUTF8())) stream.ReadCharUTF8();
|
||||
else break;
|
||||
return stream;
|
||||
}
|
||||
|
||||
public static bool Assert(this Stream stream, byte next)
|
||||
{ if (stream.PeekByte() == next) { stream.PeekByte(); return true; } else return false; }
|
||||
public static bool Assert(this Stream stream, byte[] next)
|
||||
{
|
||||
for (var i = 0; i < next.Length; i++)
|
||||
if (!stream.Assert(next[i])) return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
public static bool AssertASCII(this Stream stream, char next)
|
||||
{ if (stream.PeekCharUTF8() == next) { stream.ReadCharUTF8(); return true; } else return false; }
|
||||
public static bool AssertASCII(this Stream stream, string next)
|
||||
{
|
||||
for (var i = 0; i < next.Length; i++)
|
||||
if (!stream.AssertASCII(next[i])) return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
public static bool Assert(this Stream stream, char next)
|
||||
{ if (stream.PeekCharUTF8() == next) { stream.ReadCharUTF8(); return true; } else return false; }
|
||||
public static bool Assert(this Stream stream, string next)
|
||||
{
|
||||
for (var i = 0; i < next.Length; i++)
|
||||
if (!stream.Assert(next[i])) return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
public static long ReadIntX(this Stream stream ) => stream.IsX ?
|
||||
stream.ReadInt64() : stream.ReadUInt32Endian( );
|
||||
public static long ReadIntX(this Stream stream, bool IsBE) => stream.IsX ?
|
||||
stream.ReadInt64() : stream.ReadUInt32Endian(IsBE);
|
||||
|
||||
public static void WriteX(this Stream stream, long val, ref POF POF)
|
||||
{ if (stream.IsX) stream.Write ( val);
|
||||
else stream.WriteEndian((int)val); POF.Offsets.Add(stream.Position); }
|
||||
public static void WriteX(this Stream stream, long val, ref POF POF, bool IsBE)
|
||||
{ if (stream.IsX) stream.Write ( val );
|
||||
else stream.WriteEndian((int)val, IsBE); POF.Offsets.Add(stream.Position); }
|
||||
|
||||
public static void WriteX(this Stream stream, long val)
|
||||
{ if (stream.IsX) stream.Write ( val);
|
||||
else stream.WriteEndian((int)val); }
|
||||
public static void WriteX(this Stream stream, long val, bool IsBE)
|
||||
{ if (stream.IsX) stream.Write ( val );
|
||||
else stream.WriteEndian((int)val, IsBE); }
|
||||
|
||||
public static byte[] ReadAtOffset(this Stream stream, long Offset = -1, long Length = -1)
|
||||
{
|
||||
byte[] arr = null;
|
||||
long Position = stream.LongPosition;
|
||||
if (Offset == -1) { Position += stream.IsX ? 8 : 4; Offset = stream.ReadIntX(); }
|
||||
stream.LongPosition = Offset;
|
||||
if (Length == -1) arr = stream.NullTerminated();
|
||||
else arr = stream.ReadBytes(Length);
|
||||
stream.LongPosition = Position;
|
||||
return arr;
|
||||
}
|
||||
|
||||
public static string ReadStringAtOffset(this Stream stream, long Offset = -1, long Length = -1)
|
||||
{
|
||||
string s = null;
|
||||
long Position = stream.LongPosition;
|
||||
if (Offset == -1) { Position += stream.IsX ? 8 : 4; Offset = stream.ReadIntX(); }
|
||||
stream.LongPosition = Offset;
|
||||
if (Length == -1) s = stream.NullTerminatedUTF8();
|
||||
else s = stream.ReadStringUTF8(Length);
|
||||
stream.LongPosition = Position;
|
||||
return s;
|
||||
}
|
||||
|
||||
public static Pointer<string> ReadPointerStringShiftJIS(this Stream stream)
|
||||
{ Pointer<string> val = stream.ReadPointer<string>();
|
||||
val.Value = stream.ReadStringShiftJISAtOffset(val.Offset); return val; }
|
||||
|
||||
public static string ReadStringShiftJISAtOffset(this Stream stream, long Offset = 0, long Length = 0) =>
|
||||
Text.ShiftJIS.GetString(stream.ReadAtOffset(Offset, Length));
|
||||
|
||||
public static void WriteShiftJIS(this Stream stream, string String) =>
|
||||
stream.Write(Text.ShiftJIS.GetBytes(String));
|
||||
|
||||
public static Pointer<T> ReadPointer<T>(this Stream stream) =>
|
||||
new Pointer<T> { Offset = stream.ReadInt32() };
|
||||
|
||||
public static Pointer<string> ReadPointerString(this Stream stream)
|
||||
{ Pointer<string> val = stream.ReadPointer<string>();
|
||||
val.Value = stream.ReadStringAtOffset(val.Offset); return val; }
|
||||
|
||||
public static CountPointer<T> ReadCountPointer<T>(this Stream stream) =>
|
||||
new CountPointer<T> { Count = stream.ReadInt32(), Offset = stream.ReadInt32() };
|
||||
|
||||
public static Pointer<T> ReadPointerEndian<T>(this Stream stream) =>
|
||||
new Pointer<T> { Offset = stream.ReadInt32Endian() };
|
||||
|
||||
public static Pointer<string> ReadPointerStringEndian(this Stream stream)
|
||||
{ Pointer<string> val = stream.ReadPointerEndian<string>();
|
||||
val.Value = stream.ReadStringAtOffset(val.Offset); return val; }
|
||||
|
||||
public static CountPointer<T> ReadCountPointerEndian<T>(this Stream stream) =>
|
||||
new CountPointer<T> { Count = stream.ReadInt32Endian(), Offset = stream.ReadInt32Endian() };
|
||||
|
||||
public static Pointer<T> ReadPointerX<T>(this Stream stream) =>
|
||||
new Pointer<T> { Offset = (int)stream.ReadIntX() };
|
||||
|
||||
public static Pointer<string> ReadPointerStringX(this Stream stream)
|
||||
{ Pointer<string> val = stream.ReadPointerX<string>();
|
||||
val.Value = stream.ReadStringAtOffset(val.Offset); return val; }
|
||||
|
||||
public static CountPointer<T> ReadCountPointerX<T>(this Stream stream) =>
|
||||
new CountPointer<T> { Count = (int)stream.ReadIntX(), Offset = (int)stream.ReadIntX() };
|
||||
}
|
||||
}
|
||||
@@ -5,7 +5,7 @@ namespace KKdMainLib.IO
|
||||
{
|
||||
public static class File
|
||||
{
|
||||
public static Stream OpenReader(byte[] Data) => new Stream(new MSIO.MemoryStream(Data), Data);
|
||||
public static Stream OpenReader(byte[] Data) => new Stream(new MSIO.MemoryStream(Data));
|
||||
public static Stream OpenWriter( ) => new Stream(new MSIO.MemoryStream( ));
|
||||
|
||||
public static Stream OpenReader(string file, bool ReadAllAtOnce)
|
||||
@@ -14,7 +14,7 @@ namespace KKdMainLib.IO
|
||||
{ Stream IO = new Stream(new MSIO.FileStream(file, MSIO.FileMode.Open, MSIO.FileAccess.ReadWrite,
|
||||
MSIO.FileShare.ReadWrite)) { File = file }; return IO; }
|
||||
public static Stream OpenWriter(string file, bool SetLength0)
|
||||
{ Stream IO = OpenWriter(file); IO.SetLength(0 ); return IO; }
|
||||
{ Stream IO = OpenWriter(file); if (SetLength0) IO.SetLength(0); return IO; }
|
||||
public static Stream OpenWriter(string file, int SetLength)
|
||||
{ Stream IO = OpenWriter(file); IO.SetLength(SetLength); return IO; }
|
||||
public static Stream OpenWriter(string file)
|
||||
@@ -38,13 +38,13 @@ namespace KKdMainLib.IO
|
||||
return Data.Replace("\r", "").Split('\n'); }
|
||||
|
||||
public static void WriteAllBytes(string file, byte[] data)
|
||||
{ Stream IO = OpenWriter(file); IO.Write(data); IO.Close(); }
|
||||
{ Stream IO = OpenWriter(file, true); IO.Write(data); IO.Close(); }
|
||||
|
||||
public static void WriteAllText (string file, string data)
|
||||
{ Stream IO = OpenWriter(file); IO.Write(data); IO.Close(); }
|
||||
{ Stream IO = OpenWriter(file, true); IO.Write(data); IO.Close(); }
|
||||
|
||||
public static void WriteAllLines(string file, string[] data)
|
||||
{ Stream IO = OpenWriter(file); for (int i = 0; i < data.Length; i++)
|
||||
{ Stream IO = OpenWriter(file, true); for (int i = 0; i < data.Length; i++)
|
||||
IO.Write(data[i] + "\r\n"); IO.Close(); }
|
||||
|
||||
public static bool Exists(string file) => MSIO.File.Exists(file);
|
||||
|
||||
@@ -1,42 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
|
||||
namespace KKdMainLib.IO
|
||||
{
|
||||
public static class IOExtensions
|
||||
{
|
||||
public static string NullTerminatedASCII(this Stream stream, byte End = 0) =>
|
||||
stream.NullTerminated(End).ToASCII();
|
||||
public static string NullTerminatedUTF8 (this Stream stream, byte End = 0) =>
|
||||
stream.NullTerminated(End).ToUTF8 ();
|
||||
public static byte[] NullTerminated (this Stream stream, byte End = 0)
|
||||
{
|
||||
List<byte> s = new List<byte>();
|
||||
while (true && stream.LongPosition >= 0 && stream.LongPosition < stream.LongLength)
|
||||
{
|
||||
byte a = stream.ReadByte();
|
||||
if (a == End) break;
|
||||
else s.Add(a);
|
||||
}
|
||||
return s.ToArray();
|
||||
}
|
||||
public static char PeekCharUTF8(this Stream stream)
|
||||
{ long LongPosition = stream.LongPosition; char val = stream.ReadCharUTF8();
|
||||
stream.LongPosition = LongPosition; return val; }
|
||||
public static Stream SkipWhitespace(this Stream stream)
|
||||
{
|
||||
long LongPosition = stream.LongPosition;
|
||||
while (true)
|
||||
if (char.IsWhiteSpace(stream.ReadCharUTF8())) LongPosition = stream.LongPosition;
|
||||
else { stream.LongPosition = LongPosition; break; }
|
||||
return stream;
|
||||
}
|
||||
public static bool Assert(this Stream stream, char next)
|
||||
{ if (stream.PeekCharUTF8() == next) { stream.ReadCharUTF8(); return true; } else return false; }
|
||||
public static bool Assert(this Stream stream, string next)
|
||||
{
|
||||
for (var i = 0; i < next.Length; i++)
|
||||
if (!stream.Assert(next[i])) return false;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,249 @@
|
||||
//Original or reader part: https://github.com/MarcosLopezC/LightJson/
|
||||
|
||||
using KKdBaseLib;
|
||||
using BaseExtensions = KKdBaseLib.Extensions;
|
||||
|
||||
namespace KKdMainLib.IO
|
||||
{
|
||||
public struct JSON : System.IDisposable
|
||||
{
|
||||
public JSON(Stream IO) => _IO = IO;
|
||||
|
||||
private Stream _IO;
|
||||
|
||||
public void Close() => _IO.Close();
|
||||
|
||||
public byte[] ToArray(bool Close = false) => _IO.ToArray(Close);
|
||||
|
||||
public MsgPack Read() => ReadValue();
|
||||
|
||||
private MsgPack ReadValue(string Key = null)
|
||||
{
|
||||
char c = _IO.SkipWhitespace().PeekCharUTF8();
|
||||
object obj = null;
|
||||
if (char.IsDigit(c))
|
||||
obj = ReadNumber ();
|
||||
else
|
||||
switch (c)
|
||||
{
|
||||
case '"': obj = ReadString (); break;
|
||||
case '{': obj = ReadObject (); break;
|
||||
case '[': obj = ReadArray (); break;
|
||||
case '-': obj = ReadNumber (); break;
|
||||
case 't':
|
||||
case 'f': obj = ReadBoolean(); break;
|
||||
case 'n': obj = ReadNull (); break;
|
||||
}
|
||||
return new MsgPack(Key, obj);
|
||||
}
|
||||
|
||||
private string ReadString()
|
||||
{
|
||||
if (!_IO.Assert('"')) return null;
|
||||
char c;
|
||||
string s = "";
|
||||
while (true)
|
||||
{
|
||||
c = _IO.ReadCharUTF8();
|
||||
|
||||
if (c == '\\')
|
||||
{
|
||||
c = _IO.ReadCharUTF8();
|
||||
|
||||
switch (char.ToLower(c))
|
||||
{
|
||||
case '"' :
|
||||
case '\\':
|
||||
case '/' : s += c; break;
|
||||
case 'b' : s += '\b'; break;
|
||||
case 'f' : s += '\f'; break;
|
||||
case 'n' : s += '\n'; break;
|
||||
case 'r' : s += '\r'; break;
|
||||
case 't' : s += '\t'; break;
|
||||
case 'u' : s += ReadUnicodeLiteral(); break;
|
||||
default: return null;
|
||||
}
|
||||
}
|
||||
else if (c == '"') break;
|
||||
else if (char.IsControl(c))
|
||||
return null;
|
||||
else s += c;
|
||||
}
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
private char ReadUnicodeLiteral() =>
|
||||
(char)((((((ReadHexDigit() << 4) | ReadHexDigit()) << 4) | ReadHexDigit()) << 4) | ReadHexDigit());
|
||||
|
||||
private int ReadHexDigit() => byte.Parse(_IO.ReadCharUTF8().ToString(),
|
||||
System.Globalization.NumberStyles.HexNumber);
|
||||
|
||||
private KKdList<MsgPack> ReadObject()
|
||||
{
|
||||
KKdList<MsgPack> Obj = KKdList<MsgPack>.New;
|
||||
if (!_IO.Assert('{')) return KKdList<MsgPack>.Null;
|
||||
if (_IO.SkipWhitespace().PeekCharUTF8() == '}')
|
||||
{ _IO.ReadCharUTF8(); return KKdList<MsgPack>.Null; }
|
||||
|
||||
string key;
|
||||
char c;
|
||||
while (true)
|
||||
{
|
||||
_IO.SkipWhitespace();
|
||||
|
||||
key = ReadString();
|
||||
if (!_IO.SkipWhitespace().Assert(':'))
|
||||
return KKdList<MsgPack>.Null;
|
||||
|
||||
Obj.Add(ReadValue(key));
|
||||
c = _IO.SkipWhitespace().PeekCharUTF8();
|
||||
|
||||
if (c == '}') { _IO.ReadCharUTF8(); break; }
|
||||
else if (c == ',') { _IO.ReadCharUTF8(); continue; }
|
||||
else return KKdList<MsgPack>.Null;
|
||||
}
|
||||
|
||||
return Obj;
|
||||
}
|
||||
|
||||
private MsgPack[] ReadArray()
|
||||
{
|
||||
KKdList<MsgPack> Obj = KKdList<MsgPack>.New;
|
||||
if (!_IO.Assert('[')) return null;
|
||||
if (_IO.SkipWhitespace().PeekCharUTF8() == ']')
|
||||
{ _IO.ReadCharUTF8(); return null; }
|
||||
|
||||
char c;
|
||||
while (true)
|
||||
{
|
||||
Obj.Add(ReadValue(null));
|
||||
c = _IO.SkipWhitespace().PeekCharUTF8();
|
||||
|
||||
if (c == ']') { _IO.ReadCharUTF8(); break; }
|
||||
else if (c == ',') { _IO.ReadCharUTF8(); continue; }
|
||||
else return null;
|
||||
}
|
||||
return Obj.ToArray();
|
||||
}
|
||||
|
||||
private object ReadNumber()
|
||||
{
|
||||
string s = " ";
|
||||
_IO.SkipWhitespace();
|
||||
if (_IO.PeekCharUTF8() == '-') s += _IO.ReadCharUTF8();
|
||||
if (_IO.PeekCharUTF8() == '0') s += _IO.ReadCharUTF8();
|
||||
else s += ReadDigits ();
|
||||
if (_IO.PeekCharUTF8() == '.') s += _IO.ReadCharUTF8() + ReadDigits();
|
||||
else
|
||||
{
|
||||
long val = long.Parse(s);
|
||||
if (val >= 0x00000000 && val < 0x000000100) return ( byte)val;
|
||||
else if (val >= -0x00000080 && val < 0x000000080) return ( sbyte)val;
|
||||
else if (val >= -0x00008000 && val < 0x000008000) return ( short)val;
|
||||
else if (val >= 0x00000000 && val < 0x000010000) return (ushort)val;
|
||||
else if (val >= -0x80000000 && val < 0x000800000) return ( int)val;
|
||||
else if (val >= 0x00000000 && val < 0x100000000) return ( uint)val;
|
||||
else return val;
|
||||
}
|
||||
|
||||
char c = _IO.PeekCharUTF8();
|
||||
if (c == 'e' || c == 'E')
|
||||
{
|
||||
s += _IO.ReadCharUTF8();
|
||||
c = _IO.PeekCharUTF8();
|
||||
if (c == '+' || c == '-') s += _IO.ReadCharUTF8();
|
||||
s += ReadDigits();
|
||||
}
|
||||
double d = s.ToDouble();
|
||||
return (float)d == d ? (float)d : d;
|
||||
}
|
||||
|
||||
private bool ReadBoolean()
|
||||
{
|
||||
char c = _IO.PeekCharUTF8();
|
||||
if (c == 't' && _IO.Assert( "true")) return true;
|
||||
else if (c == 'f' && _IO.Assert("false")) return false;
|
||||
return false;
|
||||
}
|
||||
|
||||
private object ReadNull() { _IO.Assert("null"); return null; }
|
||||
|
||||
private string ReadDigits()
|
||||
{ string s = ""; while (char.IsDigit(_IO.SkipWhitespace().
|
||||
PeekCharUTF8())) s += _IO.ReadCharUTF8(); return s; }
|
||||
|
||||
public JSON Write(MsgPack MsgPack, string End = "\n", string TabChar = " ") =>
|
||||
Write(MsgPack, End, TabChar, "", true);
|
||||
|
||||
public JSON Write(MsgPack MsgPack, bool Style = false) =>
|
||||
Write(MsgPack, "\n", " ", "", Style);
|
||||
|
||||
private JSON Write(MsgPack MsgPack, string End, string TabChar, string Tab, bool Style, bool IsArray = false)
|
||||
{
|
||||
string OldTab = Tab;
|
||||
Tab += TabChar;
|
||||
if (MsgPack.Name != null && !IsArray) _IO.Write("\"" + MsgPack.Name + "\":" + (Style ? " " : ""));
|
||||
if (MsgPack.Object == null) { WriteNil(); return this; }
|
||||
|
||||
if (MsgPack.List.NotNull)
|
||||
{
|
||||
WriteMap();
|
||||
if (Style) _IO.Write(End);
|
||||
if (MsgPack.List.Count > 1)
|
||||
for (int i = 0; i < MsgPack.List.Count; i++)
|
||||
{
|
||||
if (Style) _IO.Write(Tab);
|
||||
Write(MsgPack.List[i], End, TabChar, Tab, Style);
|
||||
if (i + 1 < MsgPack.List.Count) _IO.Write(',');
|
||||
if (Style) _IO.Write(End);
|
||||
}
|
||||
else if (MsgPack.List.Count == 1)
|
||||
{
|
||||
if (Style) _IO.Write(Tab);
|
||||
Write(MsgPack.List[0], End, TabChar, Tab, Style);
|
||||
if (Style) _IO.Write(End);
|
||||
}
|
||||
if (Style) _IO.Write(OldTab);
|
||||
WriteMap(true);
|
||||
}
|
||||
else if (MsgPack.Array != null)
|
||||
{
|
||||
WriteArr();
|
||||
if (Style) _IO.Write(End);
|
||||
if (MsgPack.Array.Length > 1)
|
||||
for (int i = 0; i < MsgPack.Array.Length; i++)
|
||||
{
|
||||
if (Style) _IO.Write(Tab);
|
||||
Write(MsgPack.Array[i], End, TabChar, Tab, Style, true);
|
||||
if (i + 1 < MsgPack.Array.Length) _IO.Write(',');
|
||||
if (Style) _IO.Write(End);
|
||||
}
|
||||
else if (MsgPack.Array.Length == 1)
|
||||
{
|
||||
if (Style) _IO.Write(Tab);
|
||||
Write(MsgPack.Array[0], End, TabChar, Tab, Style, true);
|
||||
if (Style) _IO.Write(End);
|
||||
}
|
||||
if (Style) _IO.Write(OldTab);
|
||||
WriteArr(true);
|
||||
}
|
||||
else if (MsgPack.Object is MsgPack msg) Write(msg, End, TabChar, Tab, Style);
|
||||
else if (MsgPack.Object is string str) Write(str);
|
||||
else _IO.Write(BaseExtensions.ToString(MsgPack.Object));
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
public void Dispose() => _IO.Close();
|
||||
|
||||
private void Write(string val) => _IO.Write("\"" + val
|
||||
.Replace("\\", "\\\\").Replace("/" , "\\/").Replace("\"", "\\\"")
|
||||
.Replace("\0", "\\0" ).Replace("\b", "\\b").Replace("\f", "\\f" )
|
||||
.Replace("\n", "\\n" ).Replace("\r", "\\r").Replace("\t", "\\t" ) + "\"");
|
||||
|
||||
private void WriteNil() => _IO.Write("null");
|
||||
private void WriteArr(bool End = false) => _IO.Write(End ? "]" : "[");
|
||||
private void WriteMap(bool End = false) => _IO.Write(End ? "}" : "{");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,347 @@
|
||||
using KKdBaseLib;
|
||||
|
||||
namespace KKdMainLib.IO
|
||||
{
|
||||
public struct MP : System.IDisposable
|
||||
{
|
||||
public MP(Stream IO) => _IO = IO;
|
||||
|
||||
private Stream _IO;
|
||||
|
||||
public void Close() => _IO.Close();
|
||||
|
||||
public byte[] ToArray(bool Close = false) => _IO.ToArray(Close);
|
||||
|
||||
public MsgPack Read(bool Array = false)
|
||||
{
|
||||
MsgPack MsgPack = MsgPack.New;
|
||||
byte Unk = _IO.ReadByte();
|
||||
if (!Array) { MsgPack.Name = ReadString((Types)Unk); Unk = _IO.ReadByte(); }
|
||||
Types Type = (Types)Unk;
|
||||
|
||||
if (Type >= Types.FixMap && Type <= Types.FixMapMax)
|
||||
{
|
||||
MsgPack.Object = KKdList<MsgPack>.New;
|
||||
for (int i = 0; i < Unk - (byte)Types.FixMap; i++) MsgPack.Add( Read(false));
|
||||
}
|
||||
else if (Type >= Types.FixArr && Type <= Types.FixArrMax)
|
||||
{
|
||||
MsgPack.Object = new MsgPack[Unk - (byte)Types.FixArr];
|
||||
for (int i = 0; i < Unk - (byte)Types.FixArr; i++) MsgPack[i] = Read( true);
|
||||
}
|
||||
else if (Type >= Types.FixStr && Type <= Types.FixStrMax) MsgPack.Object = ReadString(Type);
|
||||
else if (Type >= Types.PosInt && Type <= Types.PosIntMax) MsgPack.Object = Unk;
|
||||
else if (Type >= Types.NegInt && Type <= Types.NegIntMax) MsgPack.Object = (sbyte)Unk;
|
||||
else
|
||||
while (true)
|
||||
{
|
||||
if (ReadNil (ref MsgPack, ref Type)) break;
|
||||
if (ReadArr (ref MsgPack, ref Type)) break;
|
||||
if (ReadMap (ref MsgPack, ref Type)) break;
|
||||
if (ReadExt (ref MsgPack, ref Type)) break;
|
||||
if (ReadString (ref MsgPack, ref Type)) break;
|
||||
if (ReadBoolean(ref MsgPack, ref Type)) break;
|
||||
if (ReadBytes (ref MsgPack, ref Type)) break;
|
||||
if (ReadInt (ref MsgPack, ref Type)) break;
|
||||
if (ReadUInt (ref MsgPack, ref Type)) break;
|
||||
if (ReadFloat (ref MsgPack, ref Type)) break;
|
||||
break;
|
||||
}
|
||||
return MsgPack;
|
||||
}
|
||||
|
||||
private bool ReadInt (ref MsgPack MsgPack, ref Types Type)
|
||||
{
|
||||
if (Type == Types.Int8 ) MsgPack.Object = _IO.ReadSByte();
|
||||
else if (Type == Types.Int16) MsgPack.Object = _IO.ReadInt16Endian(true);
|
||||
else if (Type == Types.Int32) MsgPack.Object = _IO.ReadInt32Endian(true);
|
||||
else if (Type == Types.Int64) MsgPack.Object = _IO.ReadInt64Endian(true);
|
||||
else return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
private bool ReadUInt (ref MsgPack MsgPack, ref Types Type)
|
||||
{
|
||||
if (Type == Types.UInt8 ) MsgPack.Object = _IO.ReadByte();
|
||||
else if (Type == Types.UInt16) MsgPack.Object = _IO.ReadUInt16Endian(true);
|
||||
else if (Type == Types.UInt32) MsgPack.Object = _IO.ReadUInt32Endian(true);
|
||||
else if (Type == Types.UInt64) MsgPack.Object = _IO.ReadUInt64Endian(true);
|
||||
else return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
private bool ReadFloat (ref MsgPack MsgPack, ref Types Type)
|
||||
{
|
||||
if (Type == Types.Float32) MsgPack.Object = _IO.ReadSingleEndian(true);
|
||||
else if (Type == Types.Float64) MsgPack.Object = _IO.ReadDoubleEndian(true);
|
||||
else return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
private bool ReadBoolean(ref MsgPack MsgPack, ref Types Type)
|
||||
{
|
||||
if (Type == Types.False) MsgPack.Object = false;
|
||||
else if (Type == Types.True ) MsgPack.Object = true ;
|
||||
else return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
private bool ReadBytes (ref MsgPack MsgPack, ref Types Type)
|
||||
{
|
||||
int Length = 0;
|
||||
if (Type == Types.Bin8 ) Length = _IO.ReadByte();
|
||||
else if (Type == Types.Bin16) Length = _IO.ReadInt16Endian(true);
|
||||
else if (Type == Types.Bin32) Length = _IO.ReadInt32Endian(true);
|
||||
else return false;
|
||||
MsgPack.Object = _IO.ReadBytes(Length);
|
||||
return true;
|
||||
}
|
||||
|
||||
private bool ReadString (ref MsgPack MsgPack, ref Types Type)
|
||||
{
|
||||
string val = ReadString(Type);
|
||||
if (val != null) MsgPack.Object = val;
|
||||
else return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
private string ReadString(Types Val)
|
||||
{
|
||||
if (Val >= Types.FixStr && Val <= Types.FixStrMax)
|
||||
return _IO.ReadString(Val - Types.FixStr);
|
||||
else if (Val >= Types. Str8 && Val <= Types. Str32 )
|
||||
{
|
||||
System.Enum.TryParse(Val.ToString(), out Types Type);
|
||||
int Length = 0;
|
||||
if (Type == Types.Str8 ) Length = _IO.ReadByte();
|
||||
else if (Type == Types.Str16) Length = _IO.ReadInt16Endian(true);
|
||||
else Length = _IO.ReadInt32Endian(true);
|
||||
return _IO.ReadString(Length);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private bool ReadNil(ref MsgPack MsgPack, ref Types Type)
|
||||
{
|
||||
if (Type == Types.Nil) MsgPack.Object = null;
|
||||
else return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
private bool ReadArr(ref MsgPack MsgPack, ref Types Type)
|
||||
{
|
||||
int Length = 0;
|
||||
if (Type == Types.Arr16) Length = _IO.ReadInt16Endian(true);
|
||||
else if (Type == Types.Arr32) Length = _IO.ReadInt32Endian(true);
|
||||
else return false;
|
||||
MsgPack.Object = new MsgPack[Length];
|
||||
for (int i = 0; i < Length; i++) MsgPack[i] = Read(true);
|
||||
return true;
|
||||
}
|
||||
|
||||
private bool ReadMap(ref MsgPack MsgPack, ref Types Type)
|
||||
{
|
||||
int Length = 0;
|
||||
if (Type == Types.Map16) Length = _IO.ReadInt16Endian(true);
|
||||
else if (Type == Types.Map32) Length = _IO.ReadInt32Endian(true);
|
||||
else return false;
|
||||
MsgPack.Object = KKdList<MsgPack>.New;
|
||||
for (int i = 0; i < Length; i++) MsgPack.Add(Read());
|
||||
return true;
|
||||
}
|
||||
|
||||
private bool ReadExt(ref MsgPack MsgPack, ref Types Type)
|
||||
{
|
||||
int Length = 0;
|
||||
if (Type == Types.FixExt1 ) Length = 1 ;
|
||||
else if (Type == Types.FixExt2 ) Length = 2 ;
|
||||
else if (Type == Types.FixExt4 ) Length = 4 ;
|
||||
else if (Type == Types.FixExt8 ) Length = 8 ;
|
||||
else if (Type == Types.FixExt16) Length = 16;
|
||||
else if (Type == Types. Ext8 ) Length = _IO.ReadByte();
|
||||
else if (Type == Types. Ext16) Length = _IO.ReadInt16Endian(true);
|
||||
else if (Type == Types. Ext32) Length = _IO.ReadInt32Endian(true);
|
||||
else return false;
|
||||
MsgPack.Object = new MsgPack.Ext { Type = _IO.ReadSByte(), Data = _IO.ReadBytes(Length) };
|
||||
return true;
|
||||
}
|
||||
|
||||
public MP Write(MsgPack MsgPack, bool IsArray = false)
|
||||
{
|
||||
if (MsgPack.Name != null && !IsArray) Write(MsgPack.Name);
|
||||
Write(MsgPack.Object);
|
||||
return this;
|
||||
}
|
||||
|
||||
private void Write(object obj)
|
||||
{
|
||||
if (obj == null) { WriteNil(); return; }
|
||||
switch (obj)
|
||||
{
|
||||
case KKdList<MsgPack> val: WriteMap(val.Count );
|
||||
for (int i = 0; i < val.Count ; i++) Write(val[i]); break;
|
||||
case MsgPack[] val: WriteArr(val.Length);
|
||||
for (int i = 0; i < val.Length; i++) Write(val[i]); break;
|
||||
case MsgPack val: Write(val); break;
|
||||
case byte[] val: Write(val); break;
|
||||
case bool val: Write(val); break;
|
||||
case sbyte val: Write(val); break;
|
||||
case byte val: Write(val); break;
|
||||
case short val: Write(val); break;
|
||||
case ushort val: Write(val); break;
|
||||
case int val: Write(val); break;
|
||||
case uint val: Write(val); break;
|
||||
case long val: Write(val); break;
|
||||
case ulong val: Write(val); break;
|
||||
case float val: Write(val); break;
|
||||
case double val: Write(val); break;
|
||||
case string val: Write(val); break;
|
||||
case MsgPack.Ext val: Write(val); break;
|
||||
}
|
||||
}
|
||||
|
||||
private void Write( sbyte val) { if (val < -0x20) _IO.WriteByte(0xD0); _IO.Write(val); }
|
||||
private void Write( byte val) { if (val >= 0x80) _IO.WriteByte(0xCC); _IO.Write(val); }
|
||||
private void Write( short val) { if (( sbyte)val == val) Write(( sbyte)val);
|
||||
else if (( byte)val == val) Write(( byte)val);
|
||||
else { _IO.WriteByte(0xD1); _IO.WriteEndian(val, true); } }
|
||||
private void Write(ushort val) { if (( byte)val == val) Write(( byte)val);
|
||||
else { _IO.WriteByte(0xCD); _IO.WriteEndian(val, true); } }
|
||||
private void Write( int val) { if (( short)val == val) Write(( short)val);
|
||||
else if ((ushort)val == val) Write((ushort)val);
|
||||
else { _IO.WriteByte(0xD2); _IO.WriteEndian(val, true); } }
|
||||
private void Write( uint val) { if ((ushort)val == val) Write((ushort)val);
|
||||
else { _IO.WriteByte(0xCE); _IO.WriteEndian(val, true); } }
|
||||
private void Write( long val) { if (( int)val == val) Write(( int)val);
|
||||
else if (( uint)val == val) Write(( uint)val);
|
||||
else { _IO.WriteByte(0xD3); _IO.WriteEndian(val, true); } }
|
||||
private void Write( ulong val) { if (( uint)val == val) Write(( uint)val);
|
||||
else { _IO.WriteByte(0xCF); _IO.WriteEndian(val, true); } }
|
||||
private void Write( float val) { if (( long)val == val) Write(( long)val);
|
||||
else { _IO.WriteByte(0xCA); _IO.WriteEndian(val, true); } }
|
||||
private void Write(double val) { if (( long)val == val) Write(( long)val);
|
||||
else if (( float)val == val) Write(( float)val);
|
||||
else { _IO.WriteByte(0xCB); _IO.WriteEndian(val, true); } }
|
||||
|
||||
private void Write( bool val) =>
|
||||
_IO.WriteByte((byte)(val ? 0xC3 : 0xC2));
|
||||
|
||||
private void Write(byte[] val)
|
||||
{
|
||||
if (val == null) { WriteNil(); return; }
|
||||
|
||||
if (val.Length < 0x100)
|
||||
{ _IO.WriteByte(0xC4); _IO.WriteByte (( byte)val.Length ); }
|
||||
else if (val.Length < 0x10000)
|
||||
{ _IO.WriteByte(0xC5); _IO.WriteEndian((ushort)val.Length, true); }
|
||||
else
|
||||
{ _IO.WriteByte(0xC6); _IO.WriteEndian( val.Length, true); }
|
||||
_IO.Write(val);
|
||||
}
|
||||
|
||||
private void Write(string val)
|
||||
{
|
||||
if (val == null) { WriteNil(); return; }
|
||||
|
||||
byte[] array = Text.ToUTF8(val);
|
||||
if (array.Length < 0x20)
|
||||
_IO.WriteByte((byte)(0xA0 | (array.Length & 0x1F)));
|
||||
else if (array.Length < 0x100)
|
||||
{ _IO.WriteByte(0xD9); _IO.WriteByte (( byte)array.Length); }
|
||||
else if (array.Length < 0x10000)
|
||||
{ _IO.WriteByte(0xDA); _IO.WriteEndian((ushort)array.Length, true); }
|
||||
else
|
||||
{ _IO.WriteByte(0xDB); _IO.WriteEndian( array.Length, true); }
|
||||
_IO.Write(array);
|
||||
}
|
||||
|
||||
private void WriteNil() => _IO.WriteByte(0xC0);
|
||||
|
||||
private void WriteArr(int val)
|
||||
{
|
||||
if (val == 0) { WriteNil(); return; }
|
||||
else if (val < 0x10) _IO.WriteByte((byte)(0x90 | (val & 0x0F)));
|
||||
else if (val < 0x10000) { _IO.WriteByte(0xDC); _IO.WriteEndian((ushort)val, true); }
|
||||
else { _IO.WriteByte(0xDD); _IO.WriteEndian( val, true); }
|
||||
}
|
||||
|
||||
private void WriteMap(int val)
|
||||
{
|
||||
if (val == 0) { WriteNil(); return; }
|
||||
else if (val < 0x10) _IO.WriteByte((byte)(0x80 | (val & 0x0F)));
|
||||
else if (val < 0x10000) { _IO.WriteByte(0xDE); _IO.WriteEndian((ushort)val, true); }
|
||||
else { _IO.WriteByte(0xDF); _IO.WriteEndian( val, true); }
|
||||
}
|
||||
|
||||
private void Write(MsgPack.Ext val)
|
||||
{
|
||||
if (val.Data == null) { WriteNil(); return; }
|
||||
|
||||
if (val.Data.Length < 1 ) { WriteNil(); return; }
|
||||
else if (val.Data.Length == 1 ) _IO.WriteByte(0xD4);
|
||||
else if (val.Data.Length == 2 ) _IO.WriteByte(0xD5);
|
||||
else if (val.Data.Length == 4 ) _IO.WriteByte(0xD6);
|
||||
else if (val.Data.Length == 8 ) _IO.WriteByte(0xD7);
|
||||
else if (val.Data.Length == 16) _IO.WriteByte(0xD8);
|
||||
else
|
||||
{
|
||||
if (val.Data.Length < 0x100)
|
||||
{ _IO.WriteByte(0xC7); _IO.WriteByte (( byte)val.Data.Length); }
|
||||
else if (val.Data.Length < 0x10000)
|
||||
{ _IO.WriteByte(0xC8); _IO.WriteEndian((ushort)val.Data.Length, true); }
|
||||
else
|
||||
{ _IO.WriteByte(0xC9); _IO.WriteEndian( val.Data.Length, true); }
|
||||
}
|
||||
_IO.Write(val.Type);
|
||||
_IO.Write(val.Data);
|
||||
}
|
||||
|
||||
public void Dispose() => _IO.Close();
|
||||
}
|
||||
|
||||
public enum Types : byte
|
||||
{
|
||||
PosInt = 0b00000000,
|
||||
FixMap = 0b10000000,
|
||||
FixArr = 0b10010000,
|
||||
FixStr = 0b10100000,
|
||||
Nil = 0b11000000,
|
||||
NeverUsed = 0b11000001,
|
||||
False = 0b11000010,
|
||||
True = 0b11000011,
|
||||
Bin8 = 0b11000100,
|
||||
Bin16 = 0b11000101,
|
||||
Bin32 = 0b11000110,
|
||||
Ext8 = 0b11000111,
|
||||
Ext16 = 0b11001000,
|
||||
Ext32 = 0b11001001,
|
||||
Float32 = 0b11001010,
|
||||
Float64 = 0b11001011,
|
||||
UInt8 = 0b11001100,
|
||||
UInt16 = 0b11001101,
|
||||
UInt32 = 0b11001110,
|
||||
UInt64 = 0b11001111,
|
||||
Int8 = 0b11010000,
|
||||
Int16 = 0b11010001,
|
||||
Int32 = 0b11010010,
|
||||
Int64 = 0b11010011,
|
||||
FixExt1 = 0b11010100,
|
||||
FixExt2 = 0b11010101,
|
||||
FixExt4 = 0b11010110,
|
||||
FixExt8 = 0b11010111,
|
||||
FixExt16 = 0b11011000,
|
||||
Str8 = 0b11011001,
|
||||
Str16 = 0b11011010,
|
||||
Str32 = 0b11011011,
|
||||
Arr16 = 0b11011100,
|
||||
Arr32 = 0b11011101,
|
||||
Map16 = 0b11011110,
|
||||
Map32 = 0b11011111,
|
||||
NegInt = 0b11100000,
|
||||
PosIntMax = 0b01111111,
|
||||
FixMapMax = 0b10001111,
|
||||
FixArrMax = 0b10011111,
|
||||
FixStrMax = 0b10111111,
|
||||
NegIntMax = 0b11111111,
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,4 @@
|
||||
using System;
|
||||
using MSIO = System.IO;
|
||||
using MSIO = System.IO;
|
||||
|
||||
namespace KKdMainLib.IO
|
||||
{
|
||||
@@ -21,5 +20,7 @@ namespace KKdMainLib.IO
|
||||
MSIO.Path.Combine(path1, path2, path3, path4);
|
||||
public static string Combine(params string[] paths) =>
|
||||
MSIO.Path.Combine(paths);
|
||||
public static string GetDirectoryName(string path) =>
|
||||
MSIO.Path.GetDirectoryName(path);
|
||||
}
|
||||
}
|
||||
|
||||
+138
-205
@@ -1,5 +1,6 @@
|
||||
using System;
|
||||
using KKdMainLib.Types;
|
||||
using System.Runtime.InteropServices;
|
||||
using KKdBaseLib;
|
||||
using MSIO = System.IO;
|
||||
|
||||
namespace KKdMainLib.IO
|
||||
@@ -7,19 +8,17 @@ namespace KKdMainLib.IO
|
||||
public unsafe class Stream : IDisposable
|
||||
{
|
||||
private MSIO.Stream stream;
|
||||
private int i, i0, TempBitRead, TempBitWrite;
|
||||
private ushort ValRead;
|
||||
private byte BitRead, BitWrite, ValWrite;
|
||||
private int I, i, BitRead, BitWrite, TempBitRead, TempBitWrite, ValRead, ValWrite;
|
||||
private byte[] buf;
|
||||
private byte[] data;
|
||||
private byte* ptr;
|
||||
|
||||
private Main.Format _format = Main.Format.NULL;
|
||||
private Format _format = Format.NULL;
|
||||
|
||||
public Main.Format Format
|
||||
public Format Format
|
||||
{ get => _format;
|
||||
set { _format = value;
|
||||
IsBE = _format == Main.Format.F2BE;
|
||||
IsX = _format == Main.Format.X || _format == Main.Format.XHD; } }
|
||||
IsBE = _format == Format.F2BE;
|
||||
IsX = _format == Format.X || _format == Format.XHD; } }
|
||||
|
||||
public bool IsBE = false;
|
||||
public bool IsX = false;
|
||||
@@ -28,9 +27,12 @@ namespace KKdMainLib.IO
|
||||
public uint UIntOffset { get => (uint)LongOffset; set => LongOffset = value; }
|
||||
public long LongOffset;
|
||||
|
||||
public int Length { get => ( int)stream.Length; set => stream.SetLength(value); }
|
||||
public uint UIntLength { get => (uint)stream.Length; set => stream.SetLength(value); }
|
||||
public long LongLength { get => stream.Length; set => stream.SetLength(value); }
|
||||
public int Length { get => ( int)stream.Length - Offset;
|
||||
set => stream.SetLength(value + Offset); }
|
||||
public uint UIntLength { get => (uint)stream.Length - UIntOffset;
|
||||
set => stream.SetLength(value + UIntOffset); }
|
||||
public long LongLength { get => stream.Length - LongOffset;
|
||||
set => stream.SetLength(value + LongOffset); }
|
||||
|
||||
public int Position
|
||||
{ get => ( int)stream.Position - Offset; set => stream.Position = value + Offset; }
|
||||
@@ -46,17 +48,17 @@ namespace KKdMainLib.IO
|
||||
|
||||
public string File = null;
|
||||
|
||||
public Stream(MSIO.Stream output = null, byte[] Data = null, bool isBE = false)
|
||||
public Stream(MSIO.Stream output = null, bool isBE = false)
|
||||
{
|
||||
if (output == null) output = MSIO.Stream.Null;
|
||||
LongOffset = 0;
|
||||
BitRead = 8;
|
||||
ValRead = ValRead = BitWrite = 0;
|
||||
stream = output;
|
||||
Format = Main.Format.NULL;
|
||||
buf = new byte[16];
|
||||
Format = Format.NULL;
|
||||
buf = new byte[128];
|
||||
ptr = buf.GetPtr();
|
||||
IsBE = isBE;
|
||||
data = Data;
|
||||
}
|
||||
|
||||
public void Close() => Dispose();
|
||||
@@ -72,10 +74,7 @@ namespace KKdMainLib.IO
|
||||
{ if (offset == null) return null; return stream.Seek((long)offset, (MSIO.SeekOrigin)(int)origin); }
|
||||
|
||||
public void Dispose()
|
||||
{ CheckWrited(); Dispose(true); }
|
||||
|
||||
private void Dispose(bool disposing)
|
||||
{ if (disposing && stream != MSIO.Stream.Null) stream.Flush(); stream.Dispose(); data = null; }
|
||||
{ CW(); if (stream != MSIO.Stream.Null) { stream.Flush(); stream.Dispose(); } }
|
||||
|
||||
public MSIO.Stream BaseStream
|
||||
{ get { stream.Flush(); return stream; } set { stream = value; } }
|
||||
@@ -84,86 +83,75 @@ namespace KKdMainLib.IO
|
||||
{
|
||||
long Al = Align - Position % Align;
|
||||
if (Position % Align != 0)
|
||||
stream.Seek(Position + Al, 0);
|
||||
stream.Seek(Position + Offset + Al, 0);
|
||||
}
|
||||
|
||||
public void Align(long Align, bool SetLength)
|
||||
{
|
||||
if (SetLength) stream.SetLength(Position);
|
||||
if (SetLength) stream.SetLength(Position + Offset);
|
||||
long Al = Align - Position % Align;
|
||||
if (Position % Align != 0) stream.Seek(Position + Al, 0);
|
||||
if (SetLength) stream.SetLength(Position);
|
||||
if (Position % Align != 0) stream.Seek(Position + Offset + Al, 0);
|
||||
if (SetLength) stream.SetLength(Position + Offset);
|
||||
}
|
||||
|
||||
public void Align(long Align, bool SetLength0, bool SetLength1)
|
||||
{
|
||||
if (SetLength0) stream.SetLength(Position);
|
||||
if (SetLength0) stream.SetLength(Position + Offset);
|
||||
long Al = Align - Position % Align;
|
||||
if (Position % Align != 0) stream.Seek(Position + Al, 0);
|
||||
if (SetLength1) stream.SetLength(Position);
|
||||
if (SetLength1) stream.SetLength(Position + Offset);
|
||||
}
|
||||
|
||||
public bool ReadBoolean() => stream.ReadByte() == 1;
|
||||
public bool ReadBoolean() => stream.ReadByte() != 0;
|
||||
public sbyte ReadSByte() => ( sbyte)stream.ReadByte();
|
||||
public byte ReadByte() => ( byte)stream.ReadByte();
|
||||
public sbyte ReadInt8() => ( sbyte) IntFromArray(1);
|
||||
public byte ReadUInt8() => ( byte)UIntFromArray(1);
|
||||
public short ReadInt16() => ( short) IntFromArray(2);
|
||||
public ushort ReadUInt16() => (ushort)UIntFromArray(2);
|
||||
public int ReadInt24() => ( int) IntFromArray(3);
|
||||
public int ReadInt32() => ( int) IntFromArray(4);
|
||||
public uint ReadUInt32() => ( uint)UIntFromArray(4);
|
||||
public long ReadInt64() => IntFromArray(8);
|
||||
public ulong ReadUInt64() => UIntFromArray(8);
|
||||
public Half ReadHalf() { ushort a = ReadUInt16(); return ( Half ) a; }
|
||||
public float ReadSingle() { uint a = ReadUInt32(); return *( float*)&a; }
|
||||
public double ReadDouble() { ulong a = ReadUInt64(); return *(double*)&a; }
|
||||
public sbyte ReadInt8() => ( sbyte)stream.ReadByte();
|
||||
public byte ReadUInt8() => ( byte)stream.ReadByte();
|
||||
public short ReadInt16() { CR(); stream.Read(buf, 0, 2); return *( short*)ptr; }
|
||||
public ushort ReadUInt16() { CR(); stream.Read(buf, 0, 2); return *(ushort*)ptr; }
|
||||
public int ReadInt32() { CR(); stream.Read(buf, 0, 4); return *( int*)ptr; }
|
||||
public uint ReadUInt32() { CR(); stream.Read(buf, 0, 4); return *( uint*)ptr; }
|
||||
public long ReadInt64() { CR(); stream.Read(buf, 0, 8); return *( long*)ptr; }
|
||||
public ulong ReadUInt64() { CR(); stream.Read(buf, 0, 8); return *( ulong*)ptr; }
|
||||
public float ReadSingle() { CR(); stream.Read(buf, 0, 4); return *( float*)ptr; }
|
||||
public double ReadDouble() { CR(); stream.Read(buf, 0, 8); return *(double*)ptr; }
|
||||
|
||||
public short ReadInt16Endian() => ( short) IntFromArray(2, IsBE);
|
||||
public ushort ReadUInt16Endian() => (ushort)UIntFromArray(2, IsBE);
|
||||
public int ReadInt24Endian() => ( int) IntFromArray(3, IsBE);
|
||||
public int ReadInt32Endian() => ( int) IntFromArray(4, IsBE);
|
||||
public uint ReadUInt32Endian() => ( uint)UIntFromArray(4, IsBE);
|
||||
public long ReadInt64Endian() => IntFromArray(8, IsBE);
|
||||
public ulong ReadUInt64Endian() => UIntFromArray(8, IsBE);
|
||||
public Half ReadHalfEndian() { ushort a = ReadUInt16Endian(); return ( Half ) a; }
|
||||
public float ReadSingleEndian() { uint a = ReadUInt32Endian(); return *( float*)&a; }
|
||||
public double ReadDoubleEndian() { ulong a = ReadUInt64Endian(); return *(double*)&a; }
|
||||
public short ReadInt16Endian() { CR(); stream.Read(buf, 0, 2); buf.Endian(2, IsBE); return *( short*)ptr; }
|
||||
public ushort ReadUInt16Endian() { CR(); stream.Read(buf, 0, 2); buf.Endian(2, IsBE); return *(ushort*)ptr; }
|
||||
public int ReadInt32Endian() { CR(); stream.Read(buf, 0, 4); buf.Endian(4, IsBE); return *( int*)ptr; }
|
||||
public uint ReadUInt32Endian() { CR(); stream.Read(buf, 0, 4); buf.Endian(4, IsBE); return *( uint*)ptr; }
|
||||
public long ReadInt64Endian() { CR(); stream.Read(buf, 0, 8); buf.Endian(8, IsBE); return *( long*)ptr; }
|
||||
public ulong ReadUInt64Endian() { CR(); stream.Read(buf, 0, 8); buf.Endian(8, IsBE); return *( ulong*)ptr; }
|
||||
public float ReadSingleEndian() { CR(); stream.Read(buf, 0, 4); buf.Endian(4, IsBE); return *( float*)ptr; }
|
||||
public double ReadDoubleEndian() { CR(); stream.Read(buf, 0, 8); buf.Endian(8, IsBE); return *(double*)ptr; }
|
||||
|
||||
public short ReadInt16Endian(bool IsBE) => ( short) IntFromArray(2, IsBE);
|
||||
public ushort ReadUInt16Endian(bool IsBE) => (ushort)UIntFromArray(2, IsBE);
|
||||
public int ReadInt24Endian(bool IsBE) => ( int) IntFromArray(3, IsBE);
|
||||
public int ReadInt32Endian(bool IsBE) => ( int) IntFromArray(4, IsBE);
|
||||
public uint ReadUInt32Endian(bool IsBE) => ( uint)UIntFromArray(4, IsBE);
|
||||
public long ReadInt64Endian(bool IsBE) => IntFromArray(8, IsBE);
|
||||
public ulong ReadUInt64Endian(bool IsBE) => UIntFromArray(8, IsBE);
|
||||
public Half ReadHalfEndian(bool IsBE)
|
||||
{ ushort a = ReadUInt16Endian(IsBE); return ( Half ) a; }
|
||||
public float ReadSingleEndian(bool IsBE)
|
||||
{ uint a = ReadUInt32Endian(IsBE); return *( float*)&a; }
|
||||
public double ReadDoubleEndian(bool IsBE)
|
||||
{ ulong a = ReadUInt64Endian(IsBE); return *(double*)&a; }
|
||||
public short ReadInt16Endian(bool IsBE) { CR(); stream.Read(buf, 0, 2); buf.Endian(2, IsBE); return *( short*)ptr; }
|
||||
public ushort ReadUInt16Endian(bool IsBE) { CR(); stream.Read(buf, 0, 2); buf.Endian(2, IsBE); return *(ushort*)ptr; }
|
||||
public int ReadInt32Endian(bool IsBE) { CR(); stream.Read(buf, 0, 4); buf.Endian(4, IsBE); return *( int*)ptr; }
|
||||
public uint ReadUInt32Endian(bool IsBE) { CR(); stream.Read(buf, 0, 4); buf.Endian(4, IsBE); return *( uint*)ptr; }
|
||||
public long ReadInt64Endian(bool IsBE) { CR(); stream.Read(buf, 0, 8); buf.Endian(8, IsBE); return *( long*)ptr; }
|
||||
public ulong ReadUInt64Endian(bool IsBE) { CR(); stream.Read(buf, 0, 8); buf.Endian(8, IsBE); return *( ulong*)ptr; }
|
||||
public float ReadSingleEndian(bool IsBE) { CR(); stream.Read(buf, 0, 4); buf.Endian(4, IsBE); return *( float*)ptr; }
|
||||
public double ReadDoubleEndian(bool IsBE) { CR(); stream.Read(buf, 0, 8); buf.Endian(8, IsBE); return *(double*)ptr; }
|
||||
|
||||
public void Write(byte[] Val) => stream.Write(Val, 0, Val. Length);
|
||||
public void Write(byte[] Val, int Length) => stream.Write(Val, 0 , Length);
|
||||
public void Write(byte[] Val, int Offset, int Length) => stream.Write(Val, Offset, Length);
|
||||
public void Write(char[] val, bool UTF8 = true)
|
||||
{ if (UTF8) Write(val.ToUTF8()); else Write(val.ToASCII()); }
|
||||
public void Write(byte[] Val ) => stream.Write(Val, 0, Val.Length);
|
||||
public void Write(byte[] Val, int Length) => stream.Write(Val, 0, Length);
|
||||
public void Write(byte[] Val, int Offset, int Length) => stream.Write(Val, Offset, Length);
|
||||
public void Write(char[] val, bool UTF8 = true) => Write(UTF8 ? val.ToUTF8() : val.ToASCII());
|
||||
|
||||
public void WriteByte(byte val) => stream.WriteByte(val);
|
||||
|
||||
public void Write( bool val) => stream.WriteByte((byte)(val ? 1 : 0));
|
||||
public void Write( sbyte val) => stream.WriteByte((byte) val);
|
||||
public void Write( byte val) => stream.WriteByte( val);
|
||||
public void Write( short val) => ToArray(2, val);
|
||||
public void Write(ushort val) => ToArray(2, val);
|
||||
public void Write( int val) => ToArray(4, val);
|
||||
public void Write( uint val) => ToArray(4, val);
|
||||
public void Write( long val) => ToArray(8, val);
|
||||
public void Write( ulong val) => ToArray(8, val);
|
||||
public void Write( Half val) => ToArray(2, (ushort) val);
|
||||
public void Write( float val) => ToArray(4, *( uint*)&val);
|
||||
public void Write(double val) => ToArray(8, *(ulong*)&val);
|
||||
public void Write( short val) { CW(); *( short*)ptr = val; stream.Write(buf, 0, 2); }
|
||||
public void Write(ushort val) { CW(); *(ushort*)ptr = val; stream.Write(buf, 0, 2); }
|
||||
public void Write( int val) { CW(); *( int*)ptr = val; stream.Write(buf, 0, 4); }
|
||||
public void Write( uint val) { CW(); *( uint*)ptr = val; stream.Write(buf, 0, 4); }
|
||||
public void Write( long val) { CW(); *( long*)ptr = val; stream.Write(buf, 0, 8); }
|
||||
public void Write( ulong val) { CW(); *( ulong*)ptr = val; stream.Write(buf, 0, 8); }
|
||||
public void Write( float val) { CW(); *( float*)ptr = val; stream.Write(buf, 0, 4); }
|
||||
public void Write(double val) { CW(); *(double*)ptr = val; stream.Write(buf, 0, 8); }
|
||||
|
||||
public void Write( sbyte? val) => Write(val.GetValueOrDefault());
|
||||
public void Write( byte? val) => Write(val.GetValueOrDefault());
|
||||
@@ -175,144 +163,96 @@ namespace KKdMainLib.IO
|
||||
public void Write( ulong? val) => Write(val.GetValueOrDefault());
|
||||
public void Write( float? val) => Write(val.GetValueOrDefault());
|
||||
public void Write(double? val) => Write(val.GetValueOrDefault());
|
||||
|
||||
public void Write( char val, bool UTF8 = true) =>
|
||||
Write(UTF8 ? val.ToString().ToUTF8() : val.ToString().ToASCII());
|
||||
public void Write(string val, bool UTF8 = true) =>
|
||||
Write(UTF8 ? val .ToUTF8() : val .ToASCII());
|
||||
|
||||
public void Write( bool* val, int Length) { for (i = 0; i < Length; i++) Write(val[i]); }
|
||||
public void Write( sbyte* val, int Length) { for (i = 0; i < Length; i++) Write(val[i]); }
|
||||
public void Write( byte* val, int Length) { for (i = 0; i < Length; i++) Write(val[i]); }
|
||||
public void Write( short* val, int Length) { for (i = 0; i < Length; i++) Write(val[i]); }
|
||||
public void Write(ushort* val, int Length) { for (i = 0; i < Length; i++) Write(val[i]); }
|
||||
public void Write( int* val, int Length) { for (i = 0; i < Length; i++) Write(val[i]); }
|
||||
public void Write( uint* val, int Length) { for (i = 0; i < Length; i++) Write(val[i]); }
|
||||
public void Write( long* val, int Length) { for (i = 0; i < Length; i++) Write(val[i]); }
|
||||
public void Write( ulong* val, int Length) { for (i = 0; i < Length; i++) Write(val[i]); }
|
||||
public void Write( float* val, int Length) { for (i = 0; i < Length; i++) Write(val[i]); }
|
||||
public void Write(double* val, int Length) { for (i = 0; i < Length; i++) Write(val[i]); }
|
||||
public void WriteEndian( short val) { CW(); *( short*)ptr = val; buf.Endian(2, IsBE); stream.Write(buf, 0, 2); }
|
||||
public void WriteEndian(ushort val) { CW(); *(ushort*)ptr = val; buf.Endian(2, IsBE); stream.Write(buf, 0, 2); }
|
||||
public void WriteEndian( int val) { CW(); *( int*)ptr = val; buf.Endian(4, IsBE); stream.Write(buf, 0, 4); }
|
||||
public void WriteEndian( uint val) { CW(); *( uint*)ptr = val; buf.Endian(4, IsBE); stream.Write(buf, 0, 4); }
|
||||
public void WriteEndian( long val) { CW(); *( long*)ptr = val; buf.Endian(8, IsBE); stream.Write(buf, 0, 8); }
|
||||
public void WriteEndian( ulong val) { CW(); *( ulong*)ptr = val; buf.Endian(8, IsBE); stream.Write(buf, 0, 8); }
|
||||
public void WriteEndian( float val) { CW(); *( float*)ptr = val; buf.Endian(4, IsBE); stream.Write(buf, 0, 4); }
|
||||
public void WriteEndian(double val) { CW(); *(double*)ptr = val; buf.Endian(8, IsBE); stream.Write(buf, 0, 8); }
|
||||
|
||||
public void WriteEndian( short val, bool IsBE)
|
||||
{ CW(); *( short*)ptr = val; buf.Endian(2, IsBE); stream.Write(buf, 0, 2); }
|
||||
public void WriteEndian(ushort val, bool IsBE)
|
||||
{ CW(); *(ushort*)ptr = val; buf.Endian(2, IsBE); stream.Write(buf, 0, 2); }
|
||||
public void WriteEndian( int val, bool IsBE)
|
||||
{ CW(); *( int*)ptr = val; buf.Endian(4, IsBE); stream.Write(buf, 0, 4); }
|
||||
public void WriteEndian( uint val, bool IsBE)
|
||||
{ CW(); *( uint*)ptr = val; buf.Endian(4, IsBE); stream.Write(buf, 0, 4); }
|
||||
public void WriteEndian( long val, bool IsBE)
|
||||
{ CW(); *( long*)ptr = val; buf.Endian(8, IsBE); stream.Write(buf, 0, 8); }
|
||||
public void WriteEndian( ulong val, bool IsBE)
|
||||
{ CW(); *( ulong*)ptr = val; buf.Endian(8, IsBE); stream.Write(buf, 0, 8); }
|
||||
public void WriteEndian( float val, bool IsBE)
|
||||
{ CW(); *( float*)ptr = val; buf.Endian(4, IsBE); stream.Write(buf, 0, 4); }
|
||||
public void WriteEndian(double val, bool IsBE)
|
||||
{ CW(); *(double*)ptr = val; buf.Endian(8, IsBE); stream.Write(buf, 0, 8); }
|
||||
|
||||
public void WriteEndian( short* val, int Length) { for (i = 0; i < Length; i++) WriteEndian(val[i]); }
|
||||
public void WriteEndian(ushort* val, int Length) { for (i = 0; i < Length; i++) WriteEndian(val[i]); }
|
||||
public void WriteEndian( int* val, int Length) { for (i = 0; i < Length; i++) WriteEndian(val[i]); }
|
||||
public void WriteEndian( uint* val, int Length) { for (i = 0; i < Length; i++) WriteEndian(val[i]); }
|
||||
public void WriteEndian( long* val, int Length) { for (i = 0; i < Length; i++) WriteEndian(val[i]); }
|
||||
public void WriteEndian( ulong* val, int Length) { for (i = 0; i < Length; i++) WriteEndian(val[i]); }
|
||||
public void WriteEndian( float* val, int Length) { for (i = 0; i < Length; i++) WriteEndian(val[i]); }
|
||||
public void WriteEndian(double* val, int Length) { for (i = 0; i < Length; i++) WriteEndian(val[i]); }
|
||||
|
||||
public Half ReadHalf ( ) { ushort a = ReadUInt16 ( ); return (Half)a; }
|
||||
public Half ReadHalfEndian( ) { ushort a = ReadUInt16Endian( ); return (Half)a; }
|
||||
public Half ReadHalfEndian(bool IsBE) { ushort a = ReadUInt16Endian(IsBE); return (Half)a; }
|
||||
|
||||
public void Write ( Half val ) => Write ( (ushort ) val );
|
||||
public void WriteEndian( Half val ) => WriteEndian( (ushort ) val );
|
||||
public void WriteEndian( Half val, bool IsBE) => WriteEndian( (ushort ) val, IsBE);
|
||||
|
||||
public void WriteEndian( short* val, int Length, bool IsBE)
|
||||
{ for (i = 0; i < Length; i++) WriteEndian(val[i], IsBE); }
|
||||
public void WriteEndian(ushort* val, int Length, bool IsBE)
|
||||
{ for (i = 0; i < Length; i++) WriteEndian(val[i], IsBE); }
|
||||
public void WriteEndian( int* val, int Length, bool IsBE)
|
||||
{ for (i = 0; i < Length; i++) WriteEndian(val[i], IsBE); }
|
||||
public void WriteEndian( uint* val, int Length, bool IsBE)
|
||||
{ for (i = 0; i < Length; i++) WriteEndian(val[i], IsBE); }
|
||||
public void WriteEndian( long* val, int Length, bool IsBE)
|
||||
{ for (i = 0; i < Length; i++) WriteEndian(val[i], IsBE); }
|
||||
public void WriteEndian( ulong* val, int Length, bool IsBE)
|
||||
{ for (i = 0; i < Length; i++) WriteEndian(val[i], IsBE); }
|
||||
public void WriteEndian( float* val, int Length, bool IsBE)
|
||||
{ for (i = 0; i < Length; i++) WriteEndian(val[i], IsBE); }
|
||||
public void WriteEndian(double* val, int Length, bool IsBE)
|
||||
{ for (i = 0; i < Length; i++) WriteEndian(val[i], IsBE); }
|
||||
|
||||
public void Write( char val, bool UTF8 = true)
|
||||
{ if (UTF8) Write(val.ToString().ToUTF8()); else Write(val.ToString().ToASCII()); }
|
||||
public void Write(string val, bool UTF8 = true)
|
||||
{ if (UTF8) Write(val .ToUTF8()); else Write(val .ToASCII()); }
|
||||
|
||||
public void WriteEndian( short val) => ToArray(2, Endian(val, 2, IsBE));
|
||||
public void WriteEndian(ushort val) => ToArray(2, Endian(val, 2, IsBE));
|
||||
public void WriteEndian( int val) => ToArray(4, Endian(val, 4, IsBE));
|
||||
public void WriteEndian( uint val) => ToArray(4, Endian(val, 4, IsBE));
|
||||
public void WriteEndian( long val) => ToArray(8, Endian(val, 8, IsBE));
|
||||
public void WriteEndian( ulong val) => ToArray(8, Endian(val, 8, IsBE));
|
||||
public void WriteEndian( float val) => ToArray(4, Endian(*( uint*)&val, 4, IsBE));
|
||||
public void WriteEndian(double val) => ToArray(8, Endian(*(ulong*)&val, 8, IsBE));
|
||||
|
||||
public void WriteEndian( short val, bool IsBE) => ToArray(2, Endian(val, 2, IsBE));
|
||||
public void WriteEndian(ushort val, bool IsBE) => ToArray(2, Endian(val, 2, IsBE));
|
||||
public void WriteEndian( int val, bool IsBE) => ToArray(4, Endian(val, 4, IsBE));
|
||||
public void WriteEndian( uint val, bool IsBE) => ToArray(4, Endian(val, 4, IsBE));
|
||||
public void WriteEndian( long val, bool IsBE) => ToArray(8, Endian(val, 8, IsBE));
|
||||
public void WriteEndian( ulong val, bool IsBE) => ToArray(8, Endian(val, 8, IsBE));
|
||||
public void WriteEndian( float val, bool IsBE) => ToArray(4, Endian(*( uint*)&val, 4, IsBE));
|
||||
public void WriteEndian(double val, bool IsBE) => ToArray(8, Endian(*(ulong*)&val, 8, IsBE));
|
||||
|
||||
public long Endian( long BE, byte Length, bool IsBE)
|
||||
{ if (IsBE) { for (byte i = 0; i < Length; i++) { buf[i] = (byte)BE; BE >>= 8; } BE = 0;
|
||||
for (byte i = 0; i < Length; i++) { BE |= buf[i]; if (i < Length - 1) BE <<= 8; } } return BE; }
|
||||
|
||||
public ulong Endian( ulong BE, byte Length, bool IsBE)
|
||||
{ if (IsBE) { for (byte i = 0; i < Length; i++) { buf[i] = (byte)BE; BE >>= 8; } BE = 0;
|
||||
for (byte i = 0; i < Length; i++) { BE |= buf[i]; if (i < Length - 1) BE <<= 8; } } return BE; }
|
||||
|
||||
private void ToArray(byte L, long val)
|
||||
{ CheckWrited(); for (i = 0; i < L; i++) { buf[i] = (byte)val; val >>= 8; } Write(buf, L); }
|
||||
|
||||
private void ToArray(byte L, ulong val)
|
||||
{ CheckWrited(); for (i = 0; i < L; i++) { buf[i] = (byte)val; val >>= 8; } Write(buf, L); }
|
||||
|
||||
private long IntFromArray(byte L, bool IsBE = false) { Read(L); long val = 0; if (IsBE)
|
||||
for (i = 0; i < L; i++) { val <<= 8; val |= buf[i ]; } else
|
||||
for (i = L; i > 0; i--) { val <<= 8; val |= buf[i - 1]; } return val; }
|
||||
|
||||
private ulong UIntFromArray(byte L, bool IsBE = false) { Read(L); ulong val = 0; if (IsBE)
|
||||
for (i = 0; i < L; i++) { val <<= 8; val |= buf[i ]; } else
|
||||
for (i = L; i > 0; i--) { val <<= 8; val |= buf[i - 1]; } return val; }
|
||||
|
||||
private void Read(byte Length) => stream.Read(buf, 0, Length);
|
||||
public char ReadChar(bool UTF8 = true)
|
||||
{ if (UTF8) return ReadCharUTF8();
|
||||
else return (char)stream.ReadByte(); }
|
||||
public char ReadChar(bool UTF8 = true) => UTF8 ? ReadCharUTF8() : (char)stream.ReadByte();
|
||||
|
||||
public char ReadCharUTF8()
|
||||
{
|
||||
byte t;
|
||||
int T;
|
||||
int val = 0;
|
||||
for (i = 0, i0 = 4; i < i0; i++)
|
||||
for (I = 0, i = 4; I < i; I++)
|
||||
{
|
||||
T = stream.ReadByte();
|
||||
if (T == -1) return '\uFFFF';
|
||||
t = (byte)T;
|
||||
|
||||
if ((t & 0xC0) == 0x80 && i > 0) val = (val << 6) | (t & 0x3F);
|
||||
else if ((t & 0x80) == 0x00 && i == 0) return (char)t;
|
||||
else if ((t & 0xE0) == 0xC0 && i == 0) { val = t & 0x1F; i0 = 2; }
|
||||
else if ((t & 0xF0) == 0xE0 && i == 0) { val = t & 0x0F; i0 = 3; }
|
||||
else if ((t & 0xF8) == 0xF0 && i == 0) { val = t & 0x07; i0 = 4; }
|
||||
if ((t & 0xC0) == 0x80 && I > 0) val = (val << 6) | (t & 0x3F);
|
||||
else if ((t & 0x80) == 0x00 && I == 0) return (char)t;
|
||||
else if ((t & 0xE0) == 0xC0 && I == 0) { val = t & 0x1F; i = 2; }
|
||||
else if ((t & 0xF0) == 0xE0 && I == 0) { val = t & 0x0F; i = 3; }
|
||||
else if ((t & 0xF8) == 0xF0 && I == 0) { val = t & 0x07; i = 4; }
|
||||
else return '\uFFFF';
|
||||
}
|
||||
return (char)val;
|
||||
}
|
||||
|
||||
public string ReadString(long Length, bool UTF8 = true)
|
||||
{ if (UTF8) return ReadStringUTF8 (Length);
|
||||
else return ReadStringASCII(Length); }
|
||||
|
||||
public string ReadString(long Length, bool UTF8 = true) =>
|
||||
UTF8 ? ReadStringUTF8(Length) : ReadStringASCII(Length);
|
||||
|
||||
public string ReadStringUTF8 (long Length) => ReadBytes(Length).ToUTF8 ();
|
||||
public string ReadStringASCII(long Length) => ReadBytes(Length).ToASCII();
|
||||
|
||||
|
||||
public string ReadString(long? Length, bool UTF8 = true)
|
||||
{ if (UTF8) return ReadStringUTF8 (Length);
|
||||
else return ReadStringASCII(Length); }
|
||||
public string ReadString(long? Length, bool UTF8 = true) =>
|
||||
UTF8 ? ReadStringUTF8(Length) : ReadStringASCII(Length);
|
||||
|
||||
public string ReadStringUTF8 (long? Length) => ReadBytes(Length).ToUTF8 ();
|
||||
public string ReadStringASCII(long? Length) => ReadBytes(Length).ToASCII();
|
||||
|
||||
public byte[] ReadBytes(long Length, int Offset = 0)
|
||||
{ byte[] Buf = new byte[Length]; if (Offset > 0) stream.Position = Offset;
|
||||
public byte[] ReadBytes(long Length, int Offset = -1)
|
||||
{ byte[] Buf = new byte[Length]; if (Offset > -1) stream.Position = Offset;
|
||||
stream.Read(Buf, 0, (int)Length); return Buf; }
|
||||
|
||||
public void ReadBytes(long Length, byte[] Buf, long Offset = 0)
|
||||
{ if (Offset > 0) stream.Position = Offset; stream.Read(Buf, 0, (int)Length); }
|
||||
public void ReadBytes(long Length, byte[] Buf, long Offset = -1)
|
||||
{ if (Offset > -1) stream.Position = Offset; stream.Read(Buf, 0, (int)Length); }
|
||||
|
||||
public byte[] ReadBytes(long? Length, int Offset = 0)
|
||||
public byte[] ReadBytes(long? Length, int Offset = -1)
|
||||
{ if (Length == null) return new byte[0]; else return ReadBytes((long)Length, Offset); }
|
||||
|
||||
public void ReadBytes(long Length, byte Bits, byte[] Buf, long Offset = 0)
|
||||
{ if (Offset > 0) stream.Seek(Offset, 0);
|
||||
if (Bits > 0 && Bits < 8) for (i0 = 0; i0 < Length; i0++) Buf[i0] = ReadBits(Bits); }
|
||||
public void ReadBytes(long Length, byte Bits, byte[] Buf, long Offset = -1)
|
||||
{ if (Offset > -1) stream.Seek(Offset, 0);
|
||||
if (Bits > 0 && Bits < 8) for (i = 0; i < Length; i++) Buf[i] = ReadBits(Bits); }
|
||||
|
||||
public byte ReadBits(byte Bits)
|
||||
{
|
||||
@@ -329,8 +269,9 @@ namespace KKdMainLib.IO
|
||||
|
||||
public byte ReadHalfByte() => ReadBits(4);
|
||||
|
||||
public void Write(byte val, byte Bits)
|
||||
public void Write(int val, byte Bits)
|
||||
{
|
||||
val &= (1 << Bits) - 1;
|
||||
BitWrite += Bits;
|
||||
TempBitWrite = 8 - BitWrite;
|
||||
if (TempBitWrite < 0)
|
||||
@@ -340,38 +281,30 @@ namespace KKdMainLib.IO
|
||||
stream.WriteByte((byte)(ValWrite | (val >> BitWrite)));
|
||||
ValWrite = 0;
|
||||
}
|
||||
ValWrite |= (byte)(val << TempBitWrite);
|
||||
ValWrite |= val << TempBitWrite;
|
||||
ValWrite &= 0xFF;
|
||||
}
|
||||
|
||||
public void CheckRead () { if (BitRead > 0) ValRead = 0; BitRead = 8; }
|
||||
public void CheckWrited() { if (BitWrite > 0) { Write(ValWrite); ValWrite = BitWrite = 0; } }
|
||||
public void CR() //CheckRead
|
||||
{ CFUTRM(); if (BitRead > 0) ValRead = 0; BitRead = 8; }
|
||||
public void CW() //CheckWrite
|
||||
{ CFUTRM(); if (BitWrite > 0) { stream.WriteByte((byte)ValWrite); ValWrite = 0; BitWrite = 0; } }
|
||||
|
||||
public byte[] ToArray(bool Close)
|
||||
{ byte[] Data = ToArray(); if (Close) this.Close(); return Data; }
|
||||
|
||||
[System.Runtime.ExceptionServices.HandleProcessCorruptedStateExceptions]
|
||||
[System.Security.SecurityCritical]
|
||||
private void CFUTRM() //CheckForUnableToReadMemory
|
||||
{ ptr = buf.GetPtr(); }
|
||||
|
||||
public byte[] ToArray()
|
||||
{
|
||||
long Offset = stream.Position;
|
||||
LongPosition = 0;
|
||||
byte[] Data = ReadBytes(stream.Length);
|
||||
LongPosition = Offset;
|
||||
long Position = stream.Position;
|
||||
byte[] Data = ReadBytes(stream.Length, 0);
|
||||
stream.Position = Position;
|
||||
return Data;
|
||||
}
|
||||
|
||||
public long ReadIntX( ) => IsX ? ReadInt64() : ReadUInt32Endian( );
|
||||
public long ReadIntX(bool IsBE) => IsX ? ReadInt64() : ReadUInt32Endian(IsBE);
|
||||
|
||||
public string ReadStringAtOffset(long Offset = 0, long Length = 0)
|
||||
{
|
||||
string s = null;
|
||||
long Position = LongPosition;
|
||||
if (Offset == 0) { Position += IsX ? 8 : 4; Offset = ReadIntX(); }
|
||||
LongPosition = Offset;
|
||||
if (Length == 0) s = this.NullTerminatedUTF8();
|
||||
else s = ReadStringUTF8(Length);
|
||||
LongPosition = Position;
|
||||
return s;
|
||||
}
|
||||
}
|
||||
|
||||
public enum SeekOrigin
|
||||
|
||||
@@ -22,6 +22,8 @@
|
||||
<ErrorReport>prompt</ErrorReport>
|
||||
<WarningLevel>4</WarningLevel>
|
||||
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
|
||||
<LangVersion>7.3</LangVersion>
|
||||
<NoWarn>IDE0044, IDE0045, IDE0046, IDE0055, IDE0059, IDE1006</NoWarn>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
|
||||
<PlatformTarget>AnyCPU</PlatformTarget>
|
||||
@@ -33,38 +35,34 @@
|
||||
<WarningLevel>4</WarningLevel>
|
||||
<DebugSymbols>true</DebugSymbols>
|
||||
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
|
||||
<LangVersion>7.3</LangVersion>
|
||||
<NoWarn>IDE0044, IDE0045, IDE0046, IDE0055, IDE0059, IDE1006</NoWarn>
|
||||
</PropertyGroup>
|
||||
<ItemGroup>
|
||||
<Compile Include="A3DA\A3DAExt.cs" />
|
||||
<Compile Include="A3DA\A3DA.cs" />
|
||||
<Compile Include="DB\Aet.cs" />
|
||||
<Compile Include="DB\Auth.cs" />
|
||||
<Compile Include="DB\Spr.cs" />
|
||||
<Compile Include="F2\Bloom.cs" />
|
||||
<Compile Include="F2\ColorCorrection.cs" />
|
||||
<Compile Include="F2\DOF.cs" />
|
||||
<Compile Include="F2\Light.cs" />
|
||||
<Compile Include="IO\Directory.cs" />
|
||||
<Compile Include="IO\Extensions.cs" />
|
||||
<Compile Include="IO\File.cs" />
|
||||
<Compile Include="IO\IOExtensions.cs" />
|
||||
<Compile Include="IO\JSON.cs" />
|
||||
<Compile Include="IO\MP.cs" />
|
||||
<Compile Include="IO\Path.cs" />
|
||||
<Compile Include="IO\Stream.cs" />
|
||||
<Compile Include="MessagePack\JSONIO.cs" />
|
||||
<Compile Include="MessagePack\MPExt.cs" />
|
||||
<Compile Include="MessagePack\MsgPack.cs" />
|
||||
<Compile Include="MessagePack\IO.cs" />
|
||||
<Compile Include="Types\Half.cs" />
|
||||
<Compile Include="Types\Vector2.cs" />
|
||||
<Compile Include="Types\Vector3.cs" />
|
||||
<Compile Include="A3DA.cs" />
|
||||
<Compile Include="Aet.cs" />
|
||||
<Compile Include="DataBank.cs" />
|
||||
<Compile Include="DCC.cs" />
|
||||
<Compile Include="DEX.cs" />
|
||||
<Compile Include="DIVAFILE.cs" />
|
||||
<Compile Include="Extensions.cs" />
|
||||
<Compile Include="FARC.cs" />
|
||||
<Compile Include="Main.cs" />
|
||||
<Compile Include="MathExtensions.cs" />
|
||||
<Compile Include="PDHeader.cs" />
|
||||
<Compile Include="POF.cs" />
|
||||
<Compile Include="Mot.cs" />
|
||||
<Compile Include="STR.cs" />
|
||||
<Compile Include="Text.cs" />
|
||||
<Compile Include="Xml.cs" />
|
||||
<Compile Include="Properties\AssemblyInfo.cs" />
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
@@ -72,8 +70,12 @@
|
||||
<Reference Include="System.Drawing" />
|
||||
<Reference Include="System.Numerics" />
|
||||
<Reference Include="System.Windows.Forms" />
|
||||
<Reference Include="System.Xml" />
|
||||
<Reference Include="System.Xml.Linq" />
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ProjectReference Include="..\KKdBaseLib\KKdBaseLib.csproj">
|
||||
<Project>{437f63f1-8c23-429e-ab14-38b85c9edb16}</Project>
|
||||
<Name>KKdBaseLib</Name>
|
||||
</ProjectReference>
|
||||
</ItemGroup>
|
||||
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
|
||||
</Project>
|
||||
+26
-184
@@ -1,7 +1,8 @@
|
||||
using System;
|
||||
using System.Windows.Forms;
|
||||
using System.Linq;
|
||||
using System.Globalization;
|
||||
using System.Collections.Generic;
|
||||
using KKdBaseLib;
|
||||
|
||||
namespace KKdMainLib
|
||||
{
|
||||
@@ -38,109 +39,6 @@ namespace KKdMainLib
|
||||
else Console.Write (TimeFormatHHmmssfff + " - " + Text,
|
||||
time.Hours, time.Minutes, time.Seconds, time.Milliseconds);
|
||||
}
|
||||
|
||||
private static string GetArgs(string name, bool And, params string[] ext)
|
||||
{
|
||||
string Out = "";
|
||||
if (And) Out = "|";
|
||||
Out += name + " files (";
|
||||
for (int i = 0; i < ext.Length; i++)
|
||||
{ Out += "*." + ext[i]; if (i + 1 < ext.Length) Out += ", "; }
|
||||
Out += ")|";
|
||||
for (int i = 0; i < ext.Length; i++)
|
||||
{ Out += "*." + ext[i]; if (i + 1 < ext.Length) Out += ";"; }
|
||||
|
||||
return Out;
|
||||
}
|
||||
|
||||
private static string GetArgs(string name, params string[] ext)
|
||||
{
|
||||
string Out = name + " files (";
|
||||
for (int i = 0; i < ext.Length; i++)
|
||||
{ Out += "*." + ext[i]; if (i + 1 < ext.Length) Out += ", "; }
|
||||
Out += ")|";
|
||||
for (int i = 0; i < ext.Length; i++)
|
||||
{ Out += "*." + ext[i]; if (i + 1 < ext.Length) Out += ";"; }
|
||||
|
||||
return Out;
|
||||
}
|
||||
|
||||
public static string Choose(int code, string filetype, out string[] FileNames)
|
||||
{
|
||||
string MsgPack = GetArgs("MessagePack", true, "mp");
|
||||
string JSON = GetArgs("JSON", true, "json");
|
||||
string BIN = GetArgs("BIN", true, "bin");
|
||||
string XML = GetArgs("XML", true, "xml");
|
||||
|
||||
FileNames = new string[0];
|
||||
if (code == 1)
|
||||
{
|
||||
Console.WriteLine("Choose file(s) to open:");
|
||||
OpenFileDialog ofd = new OpenFileDialog { InitialDirectory =
|
||||
Application.StartupPath, Multiselect = true };
|
||||
|
||||
if (filetype == "a3da") ofd.Filter = GetArgs("A3DA", "a3da", "json", "mp") +
|
||||
GetArgs("A3DA", true, "a3da") + JSON + MsgPack;
|
||||
else if (filetype == "bin" ) ofd.Filter = GetArgs("BIN" , "bin", "json", "mp") +
|
||||
BIN + JSON + MsgPack;
|
||||
else if (filetype == "bon" ) ofd.Filter = GetArgs("BON" , "bon", "bin", "json", "mp") +
|
||||
GetArgs("BON", true, "bon") + BIN + JSON + MsgPack;
|
||||
else if (filetype == "databank") ofd.Filter = GetArgs("DAT" , "dat", "xml") +
|
||||
GetArgs("DAT", true, "dat") + XML;
|
||||
else if (filetype == "dex" ) ofd.Filter = GetArgs("DEX" , "dex", "bin", "json", "mp") +
|
||||
GetArgs("DEX", true, "dex") + BIN + JSON + MsgPack;
|
||||
else if (filetype == "diva") ofd.Filter = GetArgs("DIVA", "diva", "wav") +
|
||||
GetArgs("DIVA", true, "diva") + GetArgs("WAV", true, "wav");
|
||||
else if (filetype == "dsc" ) ofd.Filter = GetArgs("DSC" , "dsc", "json", "mp") +
|
||||
GetArgs("DSC", true, "dsc") + JSON + MsgPack;
|
||||
else if (filetype == "farc") ofd.Filter = "FARC Archives (*.farc)|*.farc";
|
||||
else if (filetype == "image") ofd.Filter = GetArgs("Image", "dds", "png") +
|
||||
GetArgs("DDS", true, "dds") + GetArgs("PNG", true, "png");
|
||||
else if (filetype == "kki") ofd.Filter = GetArgs("KKI", "kki");
|
||||
else if (filetype == "mot") ofd.Filter = GetArgs("MOT", "mot", "json", "mp") +
|
||||
GetArgs("MOT", true, "mot") + JSON + MsgPack;
|
||||
else if (filetype == "ppd") ofd.Filter = GetArgs("PPD", "ppd", "pak", "mod") +
|
||||
GetArgs("PPD", true, "ppd") + GetArgs("PAK", true, "pak") + GetArgs("MOD", true, "mod");
|
||||
else if (filetype == "str") ofd.Filter = GetArgs("STR", "str", "bin", "json", "mp") +
|
||||
GetArgs("STR", true, "str") + BIN + JSON + MsgPack;
|
||||
else if (filetype == "vag") ofd.Filter = GetArgs("VAG", "vag", "wav") +
|
||||
GetArgs("VAG", true, "vag") + GetArgs("WAV", true, "wav");
|
||||
else if (filetype == "xml") ofd.Filter = GetArgs("XML", "xml");
|
||||
else ofd.Filter = GetArgs("All;", false, "*");
|
||||
|
||||
if (ofd.ShowDialog() == DialogResult.OK)
|
||||
FileNames = ofd.FileNames;
|
||||
}
|
||||
else if (code == 2)
|
||||
{
|
||||
FolderBrowserDialog fbd = new FolderBrowserDialog();
|
||||
Console.WriteLine("Choose folder:");
|
||||
fbd.SelectedPath = Application.StartupPath;
|
||||
if (fbd.ShowDialog() == DialogResult.OK)
|
||||
return fbd.SelectedPath.ToString();
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
public static void ChooseSave(int code, string filetype,
|
||||
out string InitialDirectory, out string[] FileNames)
|
||||
{
|
||||
InitialDirectory = "";
|
||||
FileNames = new string[0];
|
||||
Console.WriteLine("Choose file to save:");
|
||||
SaveFileDialog sfd = new SaveFileDialog { InitialDirectory = Application.StartupPath };
|
||||
switch (filetype)
|
||||
{
|
||||
case "kki":
|
||||
sfd.Filter = "KKI file (*.kki)|*.kki";
|
||||
break;
|
||||
}
|
||||
if (sfd.ShowDialog() == DialogResult.OK)
|
||||
{
|
||||
InitialDirectory = sfd.InitialDirectory.ToString();
|
||||
FileNames = sfd.FileNames;
|
||||
}
|
||||
}
|
||||
|
||||
public static string NullTerminated(this string Source, ref int i, byte End)
|
||||
{
|
||||
@@ -163,8 +61,10 @@ namespace KKdMainLib
|
||||
public static bool StartsWith(this Dictionary<string, object> Dict, string[] args)
|
||||
{
|
||||
Dictionary<string, object> bufDict = new Dictionary<string, object>();
|
||||
if (Dict == null)
|
||||
Dict = new Dictionary<string, object>();
|
||||
if (Dict == null) return false;
|
||||
else if (args.Length < 1) return false;
|
||||
|
||||
args[0] = args[0].ToLower();
|
||||
if (args.Length > 1)
|
||||
{
|
||||
string[] NewArgs = new string[args.Length - 1];
|
||||
@@ -179,24 +79,21 @@ namespace KKdMainLib
|
||||
}
|
||||
|
||||
public static bool FindValue(this Dictionary<string, object> Dict,
|
||||
ref bool value, char Split, string args)
|
||||
{ if (Dict.FindValue(out string val, args.Split(Split)))
|
||||
return bool.TryParse(val, out value); return false; }
|
||||
ref bool value, char Split, string args) =>
|
||||
Dict.FindValue(out string val, args.Split(Split)) ? bool.TryParse(val, out value) : false;
|
||||
|
||||
public static bool FindValue(this Dictionary<string, object> Dict,
|
||||
ref int value, char Split, string args)
|
||||
{ if (Dict.FindValue(out string val, args.Split(Split)))
|
||||
return int.TryParse(val, out value); return false; }
|
||||
ref int value, char Split, string args) =>
|
||||
Dict.FindValue(out string val, args.Split(Split)) ? int.TryParse(val, out value) : false;
|
||||
|
||||
public static bool FindValue(this Dictionary<string, object> Dict,
|
||||
ref double value, char Split, string args)
|
||||
{ if (Dict.FindValue(out string val, args.Split(Split)))
|
||||
return val.ToDouble(out value); return false; }
|
||||
ref double value, char Split, string args) =>
|
||||
Dict.FindValue(out string val, args.Split(Split)) ? val.ToDouble( out value) : false;
|
||||
|
||||
public static bool FindValue(this Dictionary<string, object> Dict,
|
||||
ref string value, char Split, string args)
|
||||
{ if (Dict.FindValue(out string val, args.Split(Split)))
|
||||
{ value = val; return true; } return false; }
|
||||
{ value = val; return true; } return false; }
|
||||
|
||||
public static bool FindValue(this Dictionary<string, object> Dict,
|
||||
out bool value, string args)
|
||||
@@ -217,12 +114,12 @@ namespace KKdMainLib
|
||||
out int? value, string args)
|
||||
{ if (Dict.FindValue(out string val, args.Split('.' )))
|
||||
{ bool Val = int.TryParse(val, out int _value);
|
||||
value = _value; return Val; } value = null; return false; }
|
||||
value = _value; return Val; } value = null; return false; }
|
||||
|
||||
public static bool FindValue(this Dictionary<string, object> Dict,
|
||||
out double? value, string args)
|
||||
{ if (Dict.FindValue(out string val, args.Split('.' )))
|
||||
return ToDouble(val, out value); value = null; return false; }
|
||||
return val.ToDouble(out value); value = null; return false; }
|
||||
|
||||
public static bool FindValue(this Dictionary<string, object> Dict,
|
||||
out string value, string args)
|
||||
@@ -233,10 +130,11 @@ namespace KKdMainLib
|
||||
out string value, string[] args)
|
||||
{
|
||||
value = "";
|
||||
if (Dict == null) return false;
|
||||
if (Dict == null) return false;
|
||||
else if (args.Length < 1) return false;
|
||||
|
||||
if (!Dict.ContainsKey(args[0])) return false;
|
||||
args[0] = args[0].ToLower();
|
||||
if (!Dict.ContainsKey(args[0])) return false;
|
||||
else if (args.Length > 1)
|
||||
{
|
||||
string[] NewArgs = new string[args.Length - 1];
|
||||
@@ -262,7 +160,10 @@ namespace KKdMainLib
|
||||
string[] args, string value)
|
||||
{
|
||||
Dictionary<string, object> bufDict = new Dictionary<string, object>();
|
||||
if (Dict == null) Dict = new Dictionary<string, object>();
|
||||
if (Dict == null) Dict = new Dictionary<string, object>();
|
||||
else if (args.Length < 1) return;
|
||||
|
||||
args[0] = args[0].ToLower();
|
||||
if (args.Length > 1)
|
||||
{
|
||||
string[] NewArgs = new string[args.Length - 1];
|
||||
@@ -280,7 +181,10 @@ namespace KKdMainLib
|
||||
}
|
||||
else if (!Dict.ContainsKey(args[0])) Dict.Add(args[0], value);
|
||||
}
|
||||
|
||||
|
||||
public static TKey GetKey<TKey, TVal>(this Dictionary<TKey, TVal> Dict, TVal val) =>
|
||||
Dict.First((KeyValuePair<TKey, TVal> x) => x.Value.Equals(val)).Key;
|
||||
|
||||
public static string ToTitleCase(this string s)
|
||||
{ return CultureInfo.CurrentCulture.TextInfo.ToTitleCase(s); }
|
||||
|
||||
@@ -294,67 +198,5 @@ namespace KKdMainLib
|
||||
for (i = 0; i < Length; i++) B[i] = int.Parse(A[i]);
|
||||
return B;
|
||||
}
|
||||
|
||||
private static readonly string NumberDecimalSeparator =
|
||||
NumberFormatInfo.CurrentInfo.NumberDecimalSeparator;
|
||||
|
||||
public static string ToString(this bool? d) => d.GetValueOrDefault().ToString();
|
||||
public static string ToString(this bool d) => d.ToString().ToLower();
|
||||
public static string ToString(this sbyte? d) => d.GetValueOrDefault().ToString();
|
||||
public static string ToString(this sbyte d) => d.ToString();
|
||||
public static string ToString(this byte? d) => d.GetValueOrDefault().ToString();
|
||||
public static string ToString(this byte d) => d.ToString();
|
||||
public static string ToString(this short? d) => d.GetValueOrDefault().ToString();
|
||||
public static string ToString(this short d) => d.ToString();
|
||||
public static string ToString(this ushort? d) => d.GetValueOrDefault().ToString();
|
||||
public static string ToString(this ushort d) => d.ToString();
|
||||
public static string ToString(this int? d) => d.GetValueOrDefault().ToString();
|
||||
public static string ToString(this int d) => d.ToString();
|
||||
public static string ToString(this uint? d) => d.GetValueOrDefault().ToString();
|
||||
public static string ToString(this uint d) => d.ToString();
|
||||
public static string ToString(this long? d) => d.GetValueOrDefault().ToString();
|
||||
public static string ToString(this long d) => d.ToString();
|
||||
public static string ToString(this ulong? d) => d.GetValueOrDefault().ToString();
|
||||
public static string ToString(this ulong d) => d.ToString();
|
||||
public static string ToString(this float? d, byte round) => d.GetValueOrDefault().ToString(round);
|
||||
public static string ToString(this float? d) => d.GetValueOrDefault().ToString();
|
||||
public static string ToString(this float d, byte round) =>
|
||||
Math.Round(d, round).ToString().ToLower().Replace(NumberDecimalSeparator, ".");
|
||||
public static string ToString(this float d) =>
|
||||
d .ToString().ToLower().Replace(NumberDecimalSeparator, ".");
|
||||
public static string ToString(this double? d, byte round) => d.GetValueOrDefault().ToString(round);
|
||||
public static string ToString(this double? d) => d.GetValueOrDefault().ToString();
|
||||
public static string ToString(this double d, byte round) =>
|
||||
Math.Round(d, round).ToString().ToLower().Replace(NumberDecimalSeparator, ".");
|
||||
public static string ToString(this double d) =>
|
||||
d .ToString().ToLower().Replace(NumberDecimalSeparator, ".");
|
||||
public static float ToSingle(this string s) =>
|
||||
float. Parse(s.Replace(".", NumberDecimalSeparator));
|
||||
public static bool ToSingle(this string s, out float value) =>
|
||||
float.TryParse(s.Replace(".", NumberDecimalSeparator), out value);
|
||||
public static double ToDouble(this string s) =>
|
||||
double. Parse(s.Replace(".", NumberDecimalSeparator));
|
||||
public static bool ToDouble(this string s, out double value) =>
|
||||
double.TryParse(s.Replace(".", NumberDecimalSeparator), out value);
|
||||
public static bool ToSingle(this string s, out float? value)
|
||||
{ bool Val = ToSingle(s, out float val); value = val; return Val; }
|
||||
public static bool ToDouble(this string s, out double? value)
|
||||
{ bool Val = ToDouble(s, out double val); value = val; return Val; }
|
||||
|
||||
public enum Format : byte
|
||||
{
|
||||
NULL = 0,
|
||||
DT = 1,
|
||||
PDA = 2,
|
||||
DT2 = 3,
|
||||
DTe = 4,
|
||||
F = 5,
|
||||
FT = 6,
|
||||
F2LE = 7,
|
||||
F2BE = 8,
|
||||
MGF = 9,
|
||||
X = 10,
|
||||
XHD = 11,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,196 +0,0 @@
|
||||
using System;
|
||||
|
||||
namespace KKdMainLib
|
||||
{
|
||||
public static class MathExtensions
|
||||
{
|
||||
public static void FloorCeiling(ref double Value)
|
||||
{ if (Value % 1 >= 0.5) Value = (long)(Value + 0.5);
|
||||
else Value = (long) Value; }
|
||||
|
||||
public static long FloorCeiling(this double Value)
|
||||
{ if (Value % 1 >= 0.5) return (long)(Value + 0.5);
|
||||
else return (long) Value; }
|
||||
|
||||
public static int Align(this int value, int alignement, int divide = 1) =>
|
||||
((value % alignement == 0) ? value : (value + alignement - value % alignement)) / divide;
|
||||
|
||||
public static uint Align(this uint value, uint alignement, uint divide = 1) =>
|
||||
((value % alignement == 0) ? value : (value + alignement - value % alignement)) / divide;
|
||||
|
||||
public static long Align(this long value, long alignement, long divide = 1) =>
|
||||
((value % alignement == 0) ? value : (value + alignement - value % alignement)) / divide;
|
||||
|
||||
public static ulong Align(this ulong value, ulong alignement, ulong divide = 1) =>
|
||||
((value % alignement == 0) ? value : (value + alignement - value % alignement)) / divide;
|
||||
|
||||
public static byte[] buf = new byte[8];
|
||||
public static unsafe byte* bufPtr = buf.GetPtr();
|
||||
|
||||
public static unsafe long Endian(this long LE, byte Len, bool IsBE)
|
||||
{ if (IsBE) { for (byte i = 0; i < Len; i++) { bufPtr[i] = (byte)LE; LE >>= 8; } LE = 0;
|
||||
for (byte i = 0; i < Len; i++) { LE |= bufPtr[i]; if (i < Len - 1) LE <<= 8; } } return LE; }
|
||||
|
||||
public static unsafe ulong Endian(this ulong LE, byte Len, bool IsBE)
|
||||
{ if (IsBE) { for (byte i = 0; i < Len; i++) { bufPtr[i] = (byte)LE; LE >>= 8; } LE = 0;
|
||||
for (byte i = 0; i < Len; i++) { LE |= bufPtr[i]; if (i < Len - 1) LE <<= 8; } } return LE; }
|
||||
|
||||
public static sbyte CITSB(this int c)
|
||||
{
|
||||
if (c > 0x7F) c = 0x7F;
|
||||
else if (c < -0x80) c = -0x80;
|
||||
return (sbyte)c;
|
||||
}
|
||||
|
||||
public static byte CITB(this int c)
|
||||
{
|
||||
if (c > 0xFF) c = 0xFF;
|
||||
else if (c < 0x00) c = 0x00;
|
||||
return (byte)c;
|
||||
}
|
||||
|
||||
public static short CITS(this int c)
|
||||
{
|
||||
if (c > 0x7FFF) c = 0x7FFF;
|
||||
else if (c < -0x8000) c = -0x8000;
|
||||
return (short)c;
|
||||
}
|
||||
|
||||
public static ushort CITUS(this int c)
|
||||
{
|
||||
if (c > 0xFFFF) c = 0xFFFF;
|
||||
else if (c < 0x0000) c = 0x0000;
|
||||
return (ushort)c;
|
||||
}
|
||||
|
||||
public static sbyte CFTSB(this float c)
|
||||
{
|
||||
c = c.Round();
|
||||
if (c > 0x7F) c = 0x7F;
|
||||
else if (c < -0x80) c = -0x80;
|
||||
return (sbyte)c;
|
||||
}
|
||||
|
||||
public static byte CFTB(this float c)
|
||||
{
|
||||
c = c.Round();
|
||||
if (c > 0xFF) c = 0xFF;
|
||||
else if (c < 0x00) c = 0x00;
|
||||
return (byte)c;
|
||||
}
|
||||
|
||||
public static short CFTS(this float c)
|
||||
{
|
||||
c = c.Round();
|
||||
if (c > 0x7FFF) c = 0x7FFF;
|
||||
else if (c < -0x8000) c = -0x8000;
|
||||
return (short)c;
|
||||
}
|
||||
|
||||
public static ushort CFTUS(this float c)
|
||||
{
|
||||
c = c.Round();
|
||||
if (c > 0xFFFF) c = 0xFFFF;
|
||||
else if (c < 0x0000) c = 0x0000;
|
||||
return (ushort)c;
|
||||
}
|
||||
|
||||
public static int CFTI(this float c)
|
||||
{
|
||||
c = c.Round();
|
||||
if (c > 0x7FFFFFFF) c = 0x7FFFFFFF;
|
||||
else if (c < -0x80000000) c = -0x80000000;
|
||||
return (int)c;
|
||||
}
|
||||
|
||||
public static uint CFTUI(this float c)
|
||||
{
|
||||
c = c.Round();
|
||||
if (c > 0xFFFFFFFF) c = 0xFFFFFFFF;
|
||||
else if (c < 0x00000000) c = 0x00000000;
|
||||
return (uint)c;
|
||||
}
|
||||
|
||||
public static float Round(this float c) => (float)Math.Round(c);
|
||||
|
||||
public static sbyte CFTSB(this double c)
|
||||
{
|
||||
c = Math.Round(c);
|
||||
if (c > 0x7F) c = 0x7F;
|
||||
else if (c < -0x80) c = -0x80;
|
||||
return (sbyte)c;
|
||||
}
|
||||
|
||||
public static byte CFTB(this double c)
|
||||
{
|
||||
c = Math.Round(c);
|
||||
if (c > 0xFF) c = 0xFF;
|
||||
else if (c < 0x00) c = 0x00;
|
||||
return (byte)c;
|
||||
}
|
||||
|
||||
public static short CFTS(this double c)
|
||||
{
|
||||
c = Math.Round(c);
|
||||
if (c > 0x7FFF) c = 0x7FFF;
|
||||
else if (c < -0x8000) c = -0x8000;
|
||||
return (short)c;
|
||||
}
|
||||
|
||||
public static ushort CFTUS(this double c)
|
||||
{
|
||||
c = Math.Round(c);
|
||||
if (c > 0xFFFF) c = 0xFFFF;
|
||||
else if (c < 0x0000) c = 0x0000;
|
||||
return (ushort)c;
|
||||
}
|
||||
|
||||
public static int CFTI(this double c)
|
||||
{
|
||||
c = Math.Round(c);
|
||||
if (c > 0x7FFFFFFF) c = 0x7FFFFFFF;
|
||||
else if (c < -0x80000000) c = -0x80000000;
|
||||
return (int)c;
|
||||
}
|
||||
|
||||
public static uint CFTUI(this double c)
|
||||
{
|
||||
c = Math.Round(c);
|
||||
if (c > 0xFFFFFFFF) c = 0xFFFFFFFF;
|
||||
else if (c < 0x00000000) c = 0x00000000;
|
||||
return (uint)c;
|
||||
}
|
||||
|
||||
public static double Round(this double c) => Math.Round(c);
|
||||
|
||||
public static unsafe sbyte* GetPtr(this sbyte[] array)
|
||||
{ sbyte* Ptr; fixed ( sbyte* tempPtr = array) Ptr = tempPtr; return Ptr; }
|
||||
|
||||
public static unsafe byte* GetPtr(this byte[] array)
|
||||
{ byte* Ptr; fixed ( byte* tempPtr = array) Ptr = tempPtr; return Ptr; }
|
||||
|
||||
public static unsafe short* GetPtr(this short[] array)
|
||||
{ short* Ptr; fixed ( short* tempPtr = array) Ptr = tempPtr; return Ptr; }
|
||||
|
||||
public static unsafe ushort* GetPtr(this ushort[] array)
|
||||
{ ushort* Ptr; fixed (ushort* tempPtr = array) Ptr = tempPtr; return Ptr; }
|
||||
|
||||
public static unsafe int* GetPtr(this int[] array)
|
||||
{ int* Ptr; fixed ( int* tempPtr = array) Ptr = tempPtr; return Ptr; }
|
||||
|
||||
public static unsafe uint* GetPtr(this uint[] array)
|
||||
{ uint* Ptr; fixed ( uint* tempPtr = array) Ptr = tempPtr; return Ptr; }
|
||||
|
||||
public static unsafe long* GetPtr(this long[] array)
|
||||
{ long* Ptr; fixed ( long* tempPtr = array) Ptr = tempPtr; return Ptr; }
|
||||
|
||||
public static unsafe ulong* GetPtr(this ulong[] array)
|
||||
{ ulong* Ptr; fixed ( ulong* tempPtr = array) Ptr = tempPtr; return Ptr; }
|
||||
|
||||
public static unsafe float* GetPtr(this float[] array)
|
||||
{ float* Ptr; fixed ( float* tempPtr = array) Ptr = tempPtr; return Ptr; }
|
||||
|
||||
public static unsafe double* GetPtr(this double[] array)
|
||||
{ double* Ptr; fixed (double* tempPtr = array) Ptr = tempPtr; return Ptr; }
|
||||
}
|
||||
}
|
||||
@@ -1,326 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using KKdMainLib.IO;
|
||||
|
||||
namespace KKdMainLib.MessagePack
|
||||
{
|
||||
public class IO
|
||||
{
|
||||
public Stream _IO;
|
||||
|
||||
public IO( ) => _IO = File.OpenWriter();
|
||||
public IO(Stream IO) => _IO = IO;
|
||||
|
||||
public void Close() => _IO.Close();
|
||||
|
||||
public MsgPack Read(bool NotArray = true)
|
||||
{
|
||||
MsgPack MsgPack = new MsgPack();
|
||||
byte Unk = _IO.ReadByte();
|
||||
MsgPack.Type = (MsgPack.Types)Unk;
|
||||
if (NotArray)
|
||||
{
|
||||
MsgPack.Name = ReadString(MsgPack.Type);
|
||||
if (MsgPack.Name != null) { Unk = _IO.ReadByte(); MsgPack.Type = (MsgPack.Types)Unk; }
|
||||
}
|
||||
|
||||
bool FixArr = MsgPack.Type >= MsgPack.Types.FixArr && MsgPack.Type <= MsgPack.Types.FixArrMax;
|
||||
bool FixMap = MsgPack.Type >= MsgPack.Types.FixMap && MsgPack.Type <= MsgPack.Types.FixMapMax;
|
||||
bool FixStr = MsgPack.Type >= MsgPack.Types.FixStr && MsgPack.Type <= MsgPack.Types.FixStrMax;
|
||||
bool PosInt = MsgPack.Type >= MsgPack.Types.PosInt && MsgPack.Type <= MsgPack.Types.PosIntMax;
|
||||
bool NegInt = MsgPack.Type >= MsgPack.Types.NegInt && MsgPack.Type <= MsgPack.Types.NegIntMax;
|
||||
if (FixArr || FixMap || FixStr || PosInt || NegInt)
|
||||
{
|
||||
if (FixArr || FixMap)
|
||||
{
|
||||
MsgPack.Type = FixMap ? MsgPack.Types.FixMap : MsgPack.Types.FixArr;
|
||||
if (FixMap)
|
||||
{
|
||||
MsgPack.Object = new List<object>();
|
||||
for (int i = 0; i < Unk - (byte)MsgPack.Type; i++)
|
||||
MsgPack.Add(Read());
|
||||
}
|
||||
else
|
||||
{
|
||||
MsgPack.Object = new object[Unk - (byte)MsgPack.Type];
|
||||
for (int i = 0; i < Unk - (byte)MsgPack.Type; i++)
|
||||
MsgPack[i] = Read(false);
|
||||
}
|
||||
}
|
||||
else if (FixStr)
|
||||
{ MsgPack.Object = ReadString(MsgPack.Type); MsgPack.Type = MsgPack.Types.FixStr; }
|
||||
else if (PosInt)
|
||||
{ MsgPack.Object = (ulong) Unk; MsgPack.Type = MsgPack.Types.PosInt; }
|
||||
else if (NegInt)
|
||||
{ MsgPack.Object = ( long)(sbyte)Unk; MsgPack.Type = MsgPack.Types.NegInt; }
|
||||
return MsgPack;
|
||||
}
|
||||
|
||||
while (true)
|
||||
{
|
||||
if (ReadNil (ref MsgPack)) break;
|
||||
if (ReadArr (ref MsgPack)) break;
|
||||
if (ReadMap (ref MsgPack)) break;
|
||||
if (ReadExt (ref MsgPack)) break;
|
||||
if (ReadString (ref MsgPack)) break;
|
||||
if (ReadBoolean(ref MsgPack)) break;
|
||||
if (ReadBytes (ref MsgPack)) break;
|
||||
if (ReadInt (ref MsgPack)) break;
|
||||
if (ReadUInt (ref MsgPack)) break;
|
||||
if (ReadFloat (ref MsgPack)) break;
|
||||
break;
|
||||
}
|
||||
return MsgPack;
|
||||
}
|
||||
|
||||
private bool ReadInt(ref MsgPack MsgPack)
|
||||
{
|
||||
if (MsgPack.Type == MsgPack.Types.Int8 ) MsgPack.Object = (long)_IO.ReadSByte();
|
||||
else if (MsgPack.Type == MsgPack.Types.Int16) MsgPack.Object = (long)_IO.ReadInt16Endian(true);
|
||||
else if (MsgPack.Type == MsgPack.Types.Int32) MsgPack.Object = (long)_IO.ReadInt32Endian(true);
|
||||
else if (MsgPack.Type == MsgPack.Types.Int64) MsgPack.Object = (long)_IO.ReadInt64Endian(true);
|
||||
else return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
private bool ReadUInt(ref MsgPack MsgPack)
|
||||
{
|
||||
if (MsgPack.Type == MsgPack.Types.UInt8 ) MsgPack.Object = (ulong)_IO.ReadByte();
|
||||
else if (MsgPack.Type == MsgPack.Types.UInt16) MsgPack.Object = (ulong)_IO.ReadUInt16Endian(true);
|
||||
else if (MsgPack.Type == MsgPack.Types.UInt32) MsgPack.Object = (ulong)_IO.ReadUInt32Endian(true);
|
||||
else if (MsgPack.Type == MsgPack.Types.UInt64) MsgPack.Object = (ulong)_IO.ReadUInt64Endian(true);
|
||||
else return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
private bool ReadFloat(ref MsgPack MsgPack)
|
||||
{
|
||||
if (MsgPack.Type == MsgPack.Types.Float32) MsgPack.Object = _IO.ReadSingleEndian(true);
|
||||
else if (MsgPack.Type == MsgPack.Types.Float64) MsgPack.Object = _IO.ReadDoubleEndian(true);
|
||||
else return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
private bool ReadBoolean(ref MsgPack MsgPack)
|
||||
{
|
||||
if (MsgPack.Type == MsgPack.Types.False) MsgPack.Object = false;
|
||||
else if (MsgPack.Type == MsgPack.Types.True ) MsgPack.Object = true ;
|
||||
else return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
private bool ReadBytes(ref MsgPack MsgPack)
|
||||
{
|
||||
int Length = 0;
|
||||
if (MsgPack.Type == MsgPack.Types.Bin8 ) Length = _IO.ReadByte();
|
||||
else if (MsgPack.Type == MsgPack.Types.Bin16) Length = _IO.ReadInt16Endian(true);
|
||||
else if (MsgPack.Type == MsgPack.Types.Bin32) Length = _IO.ReadInt32Endian(true);
|
||||
else return false;
|
||||
MsgPack.Object = _IO.ReadBytes(Length);
|
||||
return true;
|
||||
}
|
||||
|
||||
private bool ReadString(ref MsgPack MsgPack)
|
||||
{
|
||||
string val = ReadString(MsgPack.Type);
|
||||
if (val != null) MsgPack.Object = val;
|
||||
else return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
private string ReadString(MsgPack.Types Val)
|
||||
{
|
||||
if (Val >= MsgPack.Types.FixStr && Val <= MsgPack.Types.FixStrMax)
|
||||
return _IO.ReadString(Val - MsgPack.Types.FixStr);
|
||||
else if (Val >= MsgPack.Types.Str8 && Val <= MsgPack.Types.Str32)
|
||||
{
|
||||
Enum.TryParse(Val.ToString(), out MsgPack.Types Type);
|
||||
int Length = 0;
|
||||
if (Type == MsgPack.Types.Str8 ) Length = _IO.ReadByte();
|
||||
else if (Type == MsgPack.Types.Str16) Length = _IO.ReadInt16Endian(true);
|
||||
else Length = _IO.ReadInt32Endian(true);
|
||||
return _IO.ReadString(Length);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private bool ReadNil(ref MsgPack MsgPack)
|
||||
{
|
||||
if (MsgPack.Type == MsgPack.Types.Nil)
|
||||
MsgPack.Object = null;
|
||||
else return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
private bool ReadArr(ref MsgPack MsgPack)
|
||||
{
|
||||
int Length = 0;
|
||||
if (MsgPack.Type == MsgPack.Types.Arr16) Length = _IO.ReadInt16Endian(true);
|
||||
else if (MsgPack.Type == MsgPack.Types.Arr32) Length = _IO.ReadInt32Endian(true);
|
||||
else return false;
|
||||
MsgPack.Object = new object[Length];
|
||||
for (int i = 0; i < Length; i++) MsgPack[i] = Read(false);
|
||||
return true;
|
||||
}
|
||||
|
||||
private bool ReadMap(ref MsgPack MsgPack)
|
||||
{
|
||||
int Length = 0;
|
||||
if (MsgPack.Type == MsgPack.Types.Map16) Length = _IO.ReadInt16Endian(true);
|
||||
else if (MsgPack.Type == MsgPack.Types.Map32) Length = _IO.ReadInt32Endian(true);
|
||||
else return false;
|
||||
MsgPack.Object = new List<object>();
|
||||
for (int i = 0; i < Length; i++) MsgPack.Add(Read());
|
||||
return true;
|
||||
}
|
||||
|
||||
private bool ReadExt(ref MsgPack MsgPack)
|
||||
{
|
||||
int Length = 0;
|
||||
if (MsgPack.Type == MsgPack.Types.FixExt1 ) Length = 1 ;
|
||||
else if (MsgPack.Type == MsgPack.Types.FixExt2 ) Length = 2 ;
|
||||
else if (MsgPack.Type == MsgPack.Types.FixExt4 ) Length = 4 ;
|
||||
else if (MsgPack.Type == MsgPack.Types.FixExt8 ) Length = 8 ;
|
||||
else if (MsgPack.Type == MsgPack.Types.FixExt16) Length = 16;
|
||||
else if (MsgPack.Type == MsgPack.Types. Ext8 ) Length = _IO.ReadByte();
|
||||
else if (MsgPack.Type == MsgPack.Types. Ext16) Length = _IO.ReadInt16Endian(true);
|
||||
else if (MsgPack.Type == MsgPack.Types. Ext32) Length = _IO.ReadInt32Endian(true);
|
||||
else return false;
|
||||
MsgPack.Object = new MsgPack.Ext { Type = _IO.ReadSByte(), Data = _IO.ReadBytes(Length) };
|
||||
return true;
|
||||
}
|
||||
|
||||
public IO Write(MsgPack MsgPack, bool Close)
|
||||
{ Write(MsgPack); if (Close) this.Close(); return this; }
|
||||
|
||||
public IO Write(MsgPack MsgPack)
|
||||
{
|
||||
if (MsgPack.Name != null) Write(MsgPack.Name);
|
||||
Write(MsgPack.Object);
|
||||
return this;
|
||||
}
|
||||
|
||||
private void Write(object obj)
|
||||
{
|
||||
if (obj == null) { WriteNil(); return; }
|
||||
switch (obj)
|
||||
{
|
||||
case List<object> val: WriteMap(val.Count );
|
||||
foreach (object Val in val) Write(Val); break;
|
||||
case object[] val: WriteArr(val.Length);
|
||||
foreach (object Val in val) Write(Val); break;
|
||||
case MsgPack val: Write(val); break;
|
||||
case byte[] val: Write(val); break;
|
||||
case bool val: Write(val); break;
|
||||
case sbyte val: Write(val); break;
|
||||
case byte val: Write(val); break;
|
||||
case short val: Write(val); break;
|
||||
case ushort val: Write(val); break;
|
||||
case int val: Write(val); break;
|
||||
case uint val: Write(val); break;
|
||||
case long val: Write(val); break;
|
||||
case ulong val: Write(val); break;
|
||||
case float val: Write(val); break;
|
||||
case double val: Write(val); break;
|
||||
case string val: Write(val); break;
|
||||
case MsgPack.Ext val: Write(val); break;
|
||||
}
|
||||
}
|
||||
|
||||
private void Write( sbyte val) { if (val < -0x20) _IO.Write((byte)0xD0); _IO.Write(val); }
|
||||
private void Write( byte val) { if (val >= 0x80) _IO.Write((byte)0xCC); _IO.Write(val); }
|
||||
private void Write( short val) { if (( sbyte)val == val) Write(( sbyte)val);
|
||||
else if (( byte)val == val) Write(( byte)val);
|
||||
else { _IO.Write((byte)0xD1); _IO.WriteEndian(val, true); } }
|
||||
private void Write(ushort val) { if (( byte)val == val) Write(( byte)val);
|
||||
else { _IO.Write((byte)0xCD); _IO.WriteEndian(val, true); } }
|
||||
private void Write( int val) { if (( short)val == val) Write(( short)val);
|
||||
else if ((ushort)val == val) Write((ushort)val);
|
||||
else { _IO.Write((byte)0xD2); _IO.WriteEndian(val, true); } }
|
||||
private void Write( uint val) { if ((ushort)val == val) Write((ushort)val);
|
||||
else { _IO.Write((byte)0xCE); _IO.WriteEndian(val, true); } }
|
||||
private void Write( long val) { if (( int)val == val) Write(( int)val);
|
||||
else if (( uint)val == val) Write(( uint)val);
|
||||
else { _IO.Write((byte)0xD3); _IO.WriteEndian(val, true); } }
|
||||
private void Write( ulong val) { if (( uint)val == val) Write(( uint)val);
|
||||
else { _IO.Write((byte)0xCF); _IO.WriteEndian(val, true); } }
|
||||
private void Write( float val) { if (( long)val == val) Write(( long)val);
|
||||
else { _IO.Write((byte)0xCA); _IO.WriteEndian(val, true); } }
|
||||
private void Write(double val) { if (( long)val == val) Write(( long)val);
|
||||
else if (( float)val == val) Write(( float)val);
|
||||
else { _IO.Write((byte)0xCB); _IO.WriteEndian(val, true); } }
|
||||
|
||||
private void Write( bool val)
|
||||
{ _IO.Write((byte)(val ? 0xC3 : 0xC2)); }
|
||||
|
||||
private void Write(byte[] val)
|
||||
{
|
||||
if (val == null) { WriteNil(); return; }
|
||||
|
||||
if (val.Length < 0x100)
|
||||
{ _IO.Write((byte)0xC4); _IO.Write (( byte)val.Length ); }
|
||||
else if (val.Length < 0x10000)
|
||||
{ _IO.Write((byte)0xC5); _IO.WriteEndian((ushort)val.Length, true); }
|
||||
else
|
||||
{ _IO.Write((byte)0xC6); _IO.WriteEndian( val.Length, true); }
|
||||
_IO.Write(val);
|
||||
}
|
||||
|
||||
private void Write(string val)
|
||||
{
|
||||
if (val == null) { WriteNil(); return; }
|
||||
|
||||
byte[] array = Text.ToUTF8(val);
|
||||
if (array.Length < 0x20)
|
||||
_IO.Write((byte)(0xA0 | (array.Length & 0x1F)));
|
||||
else if (array.Length < 0x100)
|
||||
{ _IO.Write((byte) 0xD9); _IO.Write (( byte)array.Length); }
|
||||
else if (array.Length < 0x10000)
|
||||
{ _IO.Write((byte )0xDA); _IO.WriteEndian((ushort)array.Length, true); }
|
||||
else
|
||||
{ _IO.Write((byte) 0xDB); _IO.WriteEndian( array.Length, true); }
|
||||
_IO.Write(array);
|
||||
}
|
||||
|
||||
private void WriteNil() => _IO.Write((byte)0xC0);
|
||||
|
||||
private void WriteArr(int val)
|
||||
{
|
||||
if (val == 0) { WriteNil(); return; }
|
||||
else if (val < 0x10) _IO.Write((byte)(0x90 | (val & 0x0F)));
|
||||
else if (val < 0x10000) { _IO.Write((byte) 0xDC); _IO.WriteEndian((ushort)val, true); }
|
||||
else { _IO.Write((byte) 0xDD); _IO.WriteEndian( val, true); }
|
||||
}
|
||||
|
||||
private void WriteMap(int val)
|
||||
{
|
||||
if (val == 0) { WriteNil(); return; }
|
||||
else if (val < 0x10) _IO.Write((byte)(0x80 | (val & 0x0F)));
|
||||
else if (val < 0x10000) { _IO.Write((byte) 0xDE); _IO.WriteEndian((ushort)val, true); }
|
||||
else { _IO.Write((byte) 0xDF); _IO.WriteEndian( val, true); }
|
||||
}
|
||||
|
||||
private void Write(MsgPack.Ext val)
|
||||
{
|
||||
if (val.Data == null) { WriteNil(); return; }
|
||||
|
||||
if (val.Data.Length < 1 ) { WriteNil(); return; }
|
||||
else if (val.Data.Length == 1 ) _IO.Write((byte)0xD4);
|
||||
else if (val.Data.Length == 2 ) _IO.Write((byte)0xD5);
|
||||
else if (val.Data.Length == 4 ) _IO.Write((byte)0xD6);
|
||||
else if (val.Data.Length == 8 ) _IO.Write((byte)0xD7);
|
||||
else if (val.Data.Length == 16) _IO.Write((byte)0xD8);
|
||||
else
|
||||
{
|
||||
if (val.Data.Length < 0x100)
|
||||
{ _IO.Write((byte)0xC7); _IO.Write (( byte)val.Data.Length); }
|
||||
else if (val.Data.Length < 0x10000)
|
||||
{ _IO.Write((byte)0xC8); _IO.WriteEndian((ushort)val.Data.Length, true); }
|
||||
else
|
||||
{ _IO.Write((byte)0xC9); _IO.WriteEndian( val.Data.Length, true); }
|
||||
}
|
||||
_IO.Write(val.Type);
|
||||
_IO.Write(val.Data);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,244 +0,0 @@
|
||||
//Original or reader part: https://github.com/MarcosLopezC/LightJson/
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using KKdMainLib.IO;
|
||||
|
||||
namespace KKdMainLib.MessagePack
|
||||
{
|
||||
public class JSONIO
|
||||
{
|
||||
public Stream _IO;
|
||||
|
||||
public JSONIO( ) => _IO = File.OpenWriter();
|
||||
public JSONIO(Stream IO) => _IO = IO;
|
||||
|
||||
public void Close() => _IO.Close();
|
||||
|
||||
public MsgPack Read() => ReadValue(null);
|
||||
|
||||
private string ReadKey() => ReadString();
|
||||
|
||||
private MsgPack ReadValue(string Key)
|
||||
{
|
||||
char c = _IO.SkipWhitespace().PeekCharUTF8();
|
||||
object obj = null;
|
||||
if (char.IsDigit(c))
|
||||
obj = ReadNumber ();
|
||||
switch (c)
|
||||
{
|
||||
case '"': obj = ReadString (); break;
|
||||
case '{': obj = ReadObject (); break;
|
||||
case '[': obj = ReadArray (); break;
|
||||
case '-': obj = ReadNumber (); break;
|
||||
case 't':
|
||||
case 'f': obj = ReadBoolean(); break;
|
||||
case 'n': obj = ReadNull (); break;
|
||||
}
|
||||
return new MsgPack(Key, obj);
|
||||
}
|
||||
|
||||
private string ReadString()
|
||||
{
|
||||
if (!_IO.Assert('"')) return null;
|
||||
char c;
|
||||
string s = "";
|
||||
while (true)
|
||||
{
|
||||
c = _IO.ReadCharUTF8();
|
||||
|
||||
if (c == '\\')
|
||||
{
|
||||
c = _IO.ReadCharUTF8();
|
||||
|
||||
switch (char.ToLower(c))
|
||||
{
|
||||
case '"' :
|
||||
case '\\':
|
||||
case '/' : s += c; break;
|
||||
case 'b' : s += '\b'; break;
|
||||
case 'f' : s += '\f'; break;
|
||||
case 'n' : s += '\n'; break;
|
||||
case 'r' : s += '\r'; break;
|
||||
case 't' : s += '\t'; break;
|
||||
case 'u' : s += ReadUnicodeLiteral(); break;
|
||||
default: return null;
|
||||
}
|
||||
}
|
||||
else if (c == '"') break;
|
||||
else if (char.IsControl(c)) return null;
|
||||
else s += c;
|
||||
}
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
private char ReadUnicodeLiteral() =>
|
||||
(char)((((((ReadHexDigit() << 4) | ReadHexDigit()) << 4) | ReadHexDigit()) << 4) | ReadHexDigit());
|
||||
|
||||
private int ReadHexDigit() => byte.Parse(_IO.ReadCharUTF8().ToString(),
|
||||
System.Globalization.NumberStyles.HexNumber);
|
||||
|
||||
private List<object> ReadObject()
|
||||
{
|
||||
List<object> Obj = new List<object>();
|
||||
if (!_IO.Assert('{')) return null;
|
||||
if (_IO.SkipWhitespace().PeekCharUTF8() == '}') { _IO.ReadCharUTF8(); return null; }
|
||||
|
||||
string key;
|
||||
while (true)
|
||||
{
|
||||
_IO.SkipWhitespace();
|
||||
|
||||
key = ReadString();
|
||||
if (!_IO.SkipWhitespace().Assert(':')) return null;
|
||||
Obj.Add(ReadValue(key));
|
||||
|
||||
_IO.SkipWhitespace();
|
||||
|
||||
var next = _IO.ReadCharUTF8();
|
||||
|
||||
if (next == '}') break;
|
||||
else if (next == ',') continue;
|
||||
else return null;
|
||||
}
|
||||
|
||||
return Obj;
|
||||
}
|
||||
|
||||
private object[] ReadArray()
|
||||
{
|
||||
List<object> Obj = new List<object>();
|
||||
if (!_IO.Assert('[')) return null;
|
||||
if (_IO.SkipWhitespace().PeekCharUTF8() == ']') { _IO.ReadCharUTF8(); return null; }
|
||||
|
||||
char c;
|
||||
while (true)
|
||||
{
|
||||
Obj.Add(ReadValue(null));
|
||||
c = _IO.SkipWhitespace().ReadCharUTF8();
|
||||
|
||||
if (c == ']') break;
|
||||
else if (c == ',') continue;
|
||||
else return null;
|
||||
}
|
||||
return Obj.ToArray();
|
||||
}
|
||||
|
||||
private object ReadNumber()
|
||||
{
|
||||
string s = " ";
|
||||
_IO.SkipWhitespace();
|
||||
if (_IO.PeekCharUTF8() == '-') s += _IO.ReadCharUTF8();
|
||||
if (_IO.PeekCharUTF8() == '0') s += _IO.ReadCharUTF8();
|
||||
else s += ReadDigits ();
|
||||
if (_IO.PeekCharUTF8() == '.') s += _IO.ReadCharUTF8() + ReadDigits();
|
||||
else return long.Parse(s);
|
||||
|
||||
char c = _IO.PeekCharUTF8();
|
||||
if (c == 'e' || c == 'E')
|
||||
{
|
||||
s += _IO.ReadCharUTF8();
|
||||
c = _IO.PeekCharUTF8();
|
||||
if (c == '+' || c == '-') s += _IO.ReadCharUTF8();
|
||||
s += ReadDigits();
|
||||
}
|
||||
return s.ToDouble();
|
||||
}
|
||||
|
||||
private bool ReadBoolean()
|
||||
{
|
||||
char c = _IO.PeekCharUTF8();
|
||||
if (c == 't' && _IO.Assert( "true")) return true;
|
||||
else if (c == 'f' && _IO.Assert("false")) return false;
|
||||
return false;
|
||||
}
|
||||
|
||||
private bool ReadNull() => _IO.Assert("null");
|
||||
|
||||
private string ReadDigits()
|
||||
{ string s = ""; while (char.IsDigit(_IO.SkipWhitespace().
|
||||
PeekCharUTF8())) s += _IO.ReadCharUTF8(); return s; }
|
||||
|
||||
public JSONIO Write(MsgPack MsgPack, bool Close, string End = "\n", string TabChar = "\t")
|
||||
{ Write(MsgPack, End, TabChar, "", true); if (Close) this.Close(); return this; }
|
||||
|
||||
public JSONIO Write(MsgPack MsgPack, bool Close, bool Style = false)
|
||||
{ Write(MsgPack, "\n", "\t", "", Style); if (Close) this.Close(); return this; }
|
||||
|
||||
private JSONIO Write(MsgPack MsgPack, string End, string TabChar, string Tab, bool Style)
|
||||
{
|
||||
string OldTab = Tab;
|
||||
Tab += TabChar;
|
||||
if (MsgPack.Name != null) _IO.Write("\"" + MsgPack.Name + "\":" + (Style ? " " : ""));
|
||||
if (MsgPack.Object == null) { WriteNil(); return this; }
|
||||
|
||||
Type type = MsgPack.Object.GetType();
|
||||
if (type == typeof(List<object>))
|
||||
{
|
||||
List<object> Obj = (List<object>)MsgPack.Object;
|
||||
WriteMap();
|
||||
if (Style) _IO.Write(End);
|
||||
for (int i = 0; i < Obj. Count; i++)
|
||||
{
|
||||
if (Style) _IO.Write(Tab);
|
||||
Write(Obj[i], Obj[i].GetType(), End, TabChar, Tab, Style);
|
||||
if (i + 1 < Obj. Count) _IO.Write(',');
|
||||
if (Style) _IO.Write(End);
|
||||
}
|
||||
if (Style) _IO.Write(OldTab);
|
||||
WriteMap(true);
|
||||
}
|
||||
else if (type == typeof(object[]))
|
||||
{
|
||||
object[] Obj = (object[])MsgPack.Object;
|
||||
WriteArr();
|
||||
if (Style) _IO.Write(End);
|
||||
for (int i = 0; i < Obj.Length; i++)
|
||||
{
|
||||
if (Style) _IO.Write(Tab);
|
||||
Write(Obj[i], Obj[i].GetType(), End, TabChar, Tab, Style);
|
||||
if (i + 1 < Obj.Length) _IO.Write(',');
|
||||
if (Style) _IO.Write(End);
|
||||
}
|
||||
if (Style) _IO.Write(OldTab);
|
||||
WriteArr(true);
|
||||
}
|
||||
else if (type == typeof(MsgPack))
|
||||
Write((MsgPack)MsgPack.Object, End, TabChar, Tab, Style);
|
||||
else Write(MsgPack.Object, type, End, TabChar, Tab, Style);
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
private void Write(object obj, Type type, string End, string TabChar, string Tab, bool Style)
|
||||
{
|
||||
if (obj == null) { WriteNil(); return; }
|
||||
switch (obj)
|
||||
{
|
||||
case MsgPack val: Write(val, End, TabChar, Tab, Style); break;
|
||||
case bool val: Write(val); break;
|
||||
case string val: Write(val); break;
|
||||
case sbyte val: _IO.Write(Main.ToString(val)); break;
|
||||
case byte val: _IO.Write(Main.ToString(val)); break;
|
||||
case short val: _IO.Write(Main.ToString(val)); break;
|
||||
case ushort val: _IO.Write(Main.ToString(val)); break;
|
||||
case int val: _IO.Write(Main.ToString(val)); break;
|
||||
case uint val: _IO.Write(Main.ToString(val)); break;
|
||||
case long val: _IO.Write(Main.ToString(val)); break;
|
||||
case ulong val: _IO.Write(Main.ToString(val)); break;
|
||||
case float val: _IO.Write(Main.ToString(val)); break;
|
||||
case double val: _IO.Write(Main.ToString(val)); break;
|
||||
}
|
||||
}
|
||||
private void Write( bool val) => _IO.Write(val ? "true" : "false");
|
||||
private void Write(string val) => _IO.Write("\"" + val
|
||||
.Replace("\\", "\\\\").Replace("/" , "\\/").Replace("\'", "\\\'").Replace("\"", "\\\"")
|
||||
.Replace("\0", "\\0" ).Replace("\a", "\\a").Replace("\b", "\\b" ).Replace("\f", "\\f" )
|
||||
.Replace("\n", "\\n" ).Replace("\r", "\\r").Replace("\t", "\\t" ) + "\"");
|
||||
|
||||
private void WriteNil() => _IO.Write("null");
|
||||
private void WriteArr(bool End = false) => _IO.Write(End ? "]" : "[");
|
||||
private void WriteMap(bool End = false) => _IO.Write(End ? "}" : "{");
|
||||
}
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
using KKdMainLib.IO;
|
||||
using MPIO = KKdMainLib.MessagePack.IO;
|
||||
|
||||
namespace KKdMainLib.MessagePack
|
||||
{
|
||||
public static class MPExt
|
||||
{
|
||||
public static MsgPack ReadMP(this string file, bool JSON = false)
|
||||
{
|
||||
MsgPack MsgPack;
|
||||
if (JSON)
|
||||
{ JSONIO IO = new JSONIO(File.OpenReader(file + ".json"));
|
||||
MsgPack = IO.Read(); IO.Close(); IO = null; }
|
||||
else
|
||||
{ MPIO IO = new MPIO(File.OpenReader(file + ".mp" ));
|
||||
MsgPack = IO.Read(); IO.Close(); IO = null; }
|
||||
return MsgPack;
|
||||
}
|
||||
|
||||
public static void Write(this MsgPack mp, bool Temp, string file, bool JSON = false)
|
||||
{ if (Temp) new MsgPack().Add(mp).Write(file, JSON).Dispose();
|
||||
else mp .Write(file, JSON); }
|
||||
|
||||
public static MsgPack Write(this MsgPack mp, string file, bool JSON = false)
|
||||
{
|
||||
if (JSON)
|
||||
{ JSONIO IO = new JSONIO(File.OpenWriter(file + ".json", true));
|
||||
IO.Write(mp, true, true); IO = null; }
|
||||
else
|
||||
{ MPIO IO = new MPIO(File.OpenWriter(file + ".mp" , true));
|
||||
IO.Write(mp, true ); IO = null; }
|
||||
return mp;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,354 +0,0 @@
|
||||
using System;
|
||||
using System.Linq;
|
||||
using System.Collections.Generic;
|
||||
|
||||
namespace KKdMainLib.MessagePack
|
||||
{
|
||||
public class MsgPack : IDisposable
|
||||
{
|
||||
public Types Type;
|
||||
public string Name;
|
||||
public object Object;
|
||||
|
||||
public MsgPack( Types Type = Types.Map32) => NewMsgPack(null, Type);
|
||||
public MsgPack(string Name, Types Type = Types.Map32) => NewMsgPack(Name, Type);
|
||||
public MsgPack( long Count) => NewMsgPack(null, Count);
|
||||
public MsgPack(string Name, long Count) => NewMsgPack(Name, Count);
|
||||
public MsgPack(string Name, Types Type, object Object)
|
||||
{ this.Name = Name; this.Type = Type; this.Object = Object; }
|
||||
public MsgPack(string Name, object Object)
|
||||
{
|
||||
switch (Object)
|
||||
{
|
||||
case List<object> val: Type = Types. Map32; break;
|
||||
case object[] val: Type = Types. Arr32; break;
|
||||
case MsgPack val: Type = Types. Map32; break;
|
||||
case byte[] val: Type = Types. Bin32; break;
|
||||
case bool val: Type = val ? Types.True : Types.False; break;
|
||||
case sbyte val: Type = Types. Int8 ; break;
|
||||
case byte val: Type = Types. UInt8 ; break;
|
||||
case short val: Type = Types. Int16; break;
|
||||
case ushort val: Type = Types. UInt16; break;
|
||||
case int val: Type = Types. Int32; break;
|
||||
case uint val: Type = Types. UInt32; break;
|
||||
case long val: Type = Types. Int64; break;
|
||||
case ulong val: Type = Types. UInt64; break;
|
||||
case float val: Type = Types.Float32; break;
|
||||
case double val: Type = Types.Float64; break;
|
||||
case string val: Type = Types. Str32; break;
|
||||
case Ext val: Type = Types. Ext32; break;
|
||||
}
|
||||
this.Name = Name; this.Object = Object;
|
||||
}
|
||||
|
||||
public static MsgPack Null => null;
|
||||
|
||||
public object this[int index]
|
||||
{ get { return ((object[])Object)[index]; }
|
||||
set { object[] Data = (object[])Object; Data[index] = value; Object = Data; } }
|
||||
|
||||
public MsgPack(List<object> Object, string Name, Types Type)
|
||||
{ this.Object = Object; this.Name = Name; this.Type = Type; }
|
||||
|
||||
private void NewMsgPack(string Name, Types Type)
|
||||
{ Object = new List<object>(); this.Name = Name; this.Type = Type; }
|
||||
|
||||
private void NewMsgPack(string Name, long Count)
|
||||
{ if (Count > 0) Object = new object[Count]; else Object = null; this.Name = Name; Type = Types.Arr32; }
|
||||
|
||||
public MsgPack Add(object obj)
|
||||
{ if (obj != null) if (typeof(List<object>) == Object.GetType())
|
||||
{ List<object> Obj = (List<object>)Object; Obj.Add(obj); Object = Obj; } return this; }
|
||||
|
||||
public MsgPack ToArray()
|
||||
{ if (typeof(List<object> ) == Object.GetType())
|
||||
{ Object = ((List<object> ) Object) .ToArray(); Type = Types.Arr32; } return this; }
|
||||
|
||||
public MsgPack ToList()
|
||||
{ if (typeof( object[]) == Object.GetType())
|
||||
{ Object = (( object[]) Object).OfType<object>().ToList (); Type = Types.Map32; } return this; }
|
||||
|
||||
public void Dispose()
|
||||
{ Type = 0; Name = null; Object = null; }
|
||||
|
||||
public MsgPack Add( sbyte? val) => Add(null, val);
|
||||
public MsgPack Add( byte? val) => Add(null, val);
|
||||
public MsgPack Add( short? val) => Add(null, val);
|
||||
public MsgPack Add(ushort? val) => Add(null, val);
|
||||
public MsgPack Add( int? val) => Add(null, val);
|
||||
public MsgPack Add( uint? val) => Add(null, val);
|
||||
public MsgPack Add( long? val) => Add(null, val);
|
||||
public MsgPack Add( ulong? val) => Add(null, val);
|
||||
public MsgPack Add( float? val) => Add(null, val);
|
||||
public MsgPack Add(double? val) => Add(null, val);
|
||||
|
||||
public MsgPack Add(byte[] val) => Add(null, val);
|
||||
public MsgPack Add(string val) => Add(null, val);
|
||||
public MsgPack Add( bool val) => Add(null, val);
|
||||
public MsgPack Add( sbyte val) => Add(null, val);
|
||||
public MsgPack Add( byte val) => Add(null, val);
|
||||
public MsgPack Add( short val) => Add(null, val);
|
||||
public MsgPack Add(ushort val) => Add(null, val);
|
||||
public MsgPack Add( int val) => Add(null, val);
|
||||
public MsgPack Add( uint val) => Add(null, val);
|
||||
public MsgPack Add( long val) => Add(null, val);
|
||||
public MsgPack Add( ulong val) => Add(null, val);
|
||||
public MsgPack Add( float val) => Add(null, val);
|
||||
public MsgPack Add(double val) => Add(null, val);
|
||||
|
||||
public MsgPack Add(string Val, sbyte? val)
|
||||
{ if (val == null) Add(Null); else Add(Val, ( sbyte)val); return this; }
|
||||
public MsgPack Add(string Val, byte? val)
|
||||
{ if (val == null) Add(Null); else Add(Val, ( byte)val); return this; }
|
||||
public MsgPack Add(string Val, short? val)
|
||||
{ if (val == null) Add(Null); else Add(Val, ( short)val); return this; }
|
||||
public MsgPack Add(string Val, ushort? val)
|
||||
{ if (val == null) Add(Null); else Add(Val, (ushort)val); return this; }
|
||||
public MsgPack Add(string Val, int? val)
|
||||
{ if (val == null) Add(Null); else Add(Val, ( int)val); return this; }
|
||||
public MsgPack Add(string Val, uint? val)
|
||||
{ if (val == null) Add(Null); else Add(Val, ( uint)val); return this; }
|
||||
public MsgPack Add(string Val, long? val)
|
||||
{ if (val == null) Add(Null); else Add(Val, ( long)val); return this; }
|
||||
public MsgPack Add(string Val, ulong? val)
|
||||
{ if (val == null) Add(Null); else Add(Val, ( ulong)val); return this; }
|
||||
public MsgPack Add(string Val, float? val)
|
||||
{ if (val == null) Add(Null); else Add(Val, ( float)val); return this; }
|
||||
public MsgPack Add(string Val, double? val)
|
||||
{ if (val == null) Add(Null); else Add(Val, (double)val); return this; }
|
||||
|
||||
public MsgPack Add(string Val, byte[] val)
|
||||
{ if (val == null) Add(Null); else
|
||||
Add(new MsgPack(Val, Types. Bin32, val)); return this; }
|
||||
public MsgPack Add(string Val, string val)
|
||||
{ if (val == null) Add(Null); else
|
||||
Add(new MsgPack(Val, Types. Str32, val)); return this; }
|
||||
public MsgPack Add(string Val, bool val)
|
||||
{ Add(new MsgPack(Val, val ?
|
||||
Types.True : Types. False, val)); return this; }
|
||||
public MsgPack Add(string Val, sbyte val)
|
||||
{ Add(new MsgPack(Val, Types. Int8, val)); return this; }
|
||||
public MsgPack Add(string Val, byte val)
|
||||
{ Add(new MsgPack(Val, Types. UInt8, val)); return this; }
|
||||
public MsgPack Add(string Val, short val)
|
||||
{ Add(new MsgPack(Val, Types. Int16, val)); return this; }
|
||||
public MsgPack Add(string Val, ushort val)
|
||||
{ Add(new MsgPack(Val, Types. UInt16, val)); return this; }
|
||||
public MsgPack Add(string Val, int val)
|
||||
{ Add(new MsgPack(Val, Types. Int32, val)); return this; }
|
||||
public MsgPack Add(string Val, uint val)
|
||||
{ Add(new MsgPack(Val, Types. UInt32, val)); return this; }
|
||||
public MsgPack Add(string Val, long val)
|
||||
{ Add(new MsgPack(Val, Types. Int64, val)); return this; }
|
||||
public MsgPack Add(string Val, ulong val)
|
||||
{ Add(new MsgPack(Val, Types. UInt64, val)); return this; }
|
||||
public MsgPack Add(string Val, float val)
|
||||
{ Add(new MsgPack(Val, Types.Float32, val)); return this; }
|
||||
public MsgPack Add(string Val, double val)
|
||||
{ Add(new MsgPack(Val, Types.Float64, val)); return this; }
|
||||
|
||||
public bool ReadBoolean(string Name) => ReadNBoolean(Name).GetValueOrDefault();
|
||||
public sbyte ReadInt8(string Name) => ReadNInt8(Name).GetValueOrDefault();
|
||||
public byte ReadUInt8(string Name) => ReadNUInt8(Name).GetValueOrDefault();
|
||||
public short ReadInt16(string Name) => ReadNInt16(Name).GetValueOrDefault();
|
||||
public ushort ReadUInt16(string Name) => ReadNUInt16(Name).GetValueOrDefault();
|
||||
public int ReadInt32(string Name) => ReadNInt32(Name).GetValueOrDefault();
|
||||
public uint ReadUInt32(string Name) => ReadNUInt32(Name).GetValueOrDefault();
|
||||
public long ReadInt64(string Name) => ReadNInt64(Name).GetValueOrDefault();
|
||||
public ulong ReadUInt64(string Name) => ReadNUInt64(Name).GetValueOrDefault();
|
||||
public float ReadSingle(string Name) => ReadNSingle(Name).GetValueOrDefault();
|
||||
public double ReadDouble(string Name) => ReadNDouble(Name).GetValueOrDefault();
|
||||
|
||||
public bool? ReadNBoolean(string Name)
|
||||
{ if (Element(Name, out MsgPack MsgPack)) return MsgPack.ReadNBoolean(); return null; }
|
||||
public sbyte? ReadNInt8(string Name)
|
||||
{ if (Element(Name, out MsgPack MsgPack)) return MsgPack. ReadNInt8(); return null; }
|
||||
public byte? ReadNUInt8(string Name)
|
||||
{ if (Element(Name, out MsgPack MsgPack)) return MsgPack. ReadNUInt8(); return null; }
|
||||
public short? ReadNInt16(string Name)
|
||||
{ if (Element(Name, out MsgPack MsgPack)) return MsgPack. ReadNInt16(); return null; }
|
||||
public ushort? ReadNUInt16(string Name)
|
||||
{ if (Element(Name, out MsgPack MsgPack)) return MsgPack. ReadNUInt16(); return null; }
|
||||
public int? ReadNInt32(string Name)
|
||||
{ if (Element(Name, out MsgPack MsgPack)) return MsgPack. ReadNInt32(); return null; }
|
||||
public uint? ReadNUInt32(string Name)
|
||||
{ if (Element(Name, out MsgPack MsgPack)) return MsgPack. ReadNUInt32(); return null; }
|
||||
public long? ReadNInt64(string Name)
|
||||
{ if (Element(Name, out MsgPack MsgPack)) return MsgPack. ReadNInt64(); return null; }
|
||||
public ulong? ReadNUInt64(string Name)
|
||||
{ if (Element(Name, out MsgPack MsgPack)) return MsgPack. ReadNUInt64(); return null; }
|
||||
public float? ReadNSingle(string Name)
|
||||
{ if (Element(Name, out MsgPack MsgPack)) return MsgPack. ReadNSingle(); return null; }
|
||||
public double? ReadNDouble(string Name)
|
||||
{ if (Element(Name, out MsgPack MsgPack)) return MsgPack. ReadNDouble(); return null; }
|
||||
public string ReadString(string Name)
|
||||
{ if (Element(Name, out MsgPack MsgPack)) return MsgPack. ReadString(); return null; }
|
||||
|
||||
public bool ReadBoolean() => ReadNBoolean().GetValueOrDefault();
|
||||
public sbyte ReadInt8() => ReadNInt8().GetValueOrDefault();
|
||||
public byte ReadUInt8() => ReadNUInt8().GetValueOrDefault();
|
||||
public short ReadInt16() => ReadNInt16().GetValueOrDefault();
|
||||
public ushort ReadUInt16() => ReadNUInt16().GetValueOrDefault();
|
||||
public int ReadInt32() => ReadNInt32().GetValueOrDefault();
|
||||
public uint ReadUInt32() => ReadNUInt32().GetValueOrDefault();
|
||||
public long ReadInt64() => ReadNInt64().GetValueOrDefault();
|
||||
public ulong ReadUInt64() => ReadNUInt64().GetValueOrDefault();
|
||||
public float ReadSingle() => ReadNSingle().GetValueOrDefault();
|
||||
public double ReadDouble() => ReadNDouble().GetValueOrDefault();
|
||||
|
||||
public bool? ReadNBoolean()
|
||||
{ if (Object == null) return null;
|
||||
if (Object.GetType() == typeof( bool)) return ( bool) Object; return null; ; }
|
||||
public sbyte? ReadNInt8()
|
||||
{ if (Object == null) return null;
|
||||
if (Object.GetType() == typeof( long)) return ( sbyte)( long)Object;
|
||||
else if (Object.GetType() == typeof( ulong)) return ( sbyte)(ulong)Object; return null; }
|
||||
public byte? ReadNUInt8()
|
||||
{ if (Object == null) return null;
|
||||
if (Object.GetType() == typeof( long)) return ( byte)( long)Object;
|
||||
else if (Object.GetType() == typeof( ulong)) return ( byte)(ulong)Object; return null; }
|
||||
public short? ReadNInt16()
|
||||
{ if (Object == null) return null;
|
||||
if (Object.GetType() == typeof( long)) return ( short)( long)Object;
|
||||
else if (Object.GetType() == typeof( ulong)) return ( short)(ulong)Object; return null; }
|
||||
public ushort? ReadNUInt16()
|
||||
{ if (Object == null) return null;
|
||||
if (Object.GetType() == typeof( long)) return (ushort)( long)Object;
|
||||
else if (Object.GetType() == typeof( ulong)) return (ushort)(ulong)Object; return null; }
|
||||
public int? ReadNInt32()
|
||||
{ if (Object == null) return null;
|
||||
if (Object.GetType() == typeof( long)) return ( int)( long)Object;
|
||||
else if (Object.GetType() == typeof( ulong)) return ( int)(ulong)Object; return null; }
|
||||
public uint? ReadNUInt32()
|
||||
{ if (Object == null) return null;
|
||||
if (Object.GetType() == typeof( long)) return ( uint)( long)Object;
|
||||
else if (Object.GetType() == typeof( ulong)) return ( uint)(ulong)Object; return null; }
|
||||
public long? ReadNInt64()
|
||||
{ if (Object == null) return null;
|
||||
if (Object.GetType() == typeof( long)) return ( long) Object;
|
||||
else if (Object.GetType() == typeof( ulong)) return ( long)(ulong)Object; return null; }
|
||||
public ulong? ReadNUInt64()
|
||||
{ if (Object == null) return null;
|
||||
if (Object.GetType() == typeof( ulong)) return ( ulong) Object;
|
||||
else if (Object.GetType() == typeof( long)) return ( ulong)( long)Object; return null; }
|
||||
public float? ReadNSingle()
|
||||
{ if (Object == null) return null;
|
||||
if (Object.GetType() == typeof(double)) return (float)(double)Object;
|
||||
else if (Object.GetType() == typeof( float)) return (float) Object;
|
||||
else if (Object.GetType() == typeof( long)) return (float)( long)Object;
|
||||
else if (Object.GetType() == typeof( ulong)) return (float)( ulong)Object; return null; }
|
||||
public double? ReadNDouble()
|
||||
{ if (Object == null) return null;
|
||||
if (Object.GetType() == typeof(double)) return (double) Object;
|
||||
else if (Object.GetType() == typeof( float)) return (double)(float)Object;
|
||||
else if (Object.GetType() == typeof( long)) return (double)( long)Object;
|
||||
else if (Object.GetType() == typeof( ulong)) return (double)(ulong)Object; return null; }
|
||||
public string ReadString()
|
||||
{ if (Object == null) return null;
|
||||
if (Object.GetType() == typeof(string)) return (string) Object; return null; }
|
||||
|
||||
public bool Element(string Name, out MsgPack MsgPack, Type Type)
|
||||
{ if (Element(out MsgPack, Name)) return MsgPack.Object.GetType() == Type; return false; }
|
||||
|
||||
public bool Element(string Name, out MsgPack MsgPack)
|
||||
{ if (Element(out MsgPack, Name)) return MsgPack != null; return false; }
|
||||
|
||||
public bool Element(out MsgPack MsgPack, string Name)
|
||||
{
|
||||
MsgPack = null;
|
||||
if (Object == null) return false;
|
||||
|
||||
Type type = Object.GetType();
|
||||
if (type == typeof(List<object>))
|
||||
{
|
||||
List<object> Obj = (List<object>)Object;
|
||||
foreach (object obj in Obj)
|
||||
{
|
||||
if (obj == null) continue; type = obj.GetType();
|
||||
if (type == typeof(MsgPack)) if (((MsgPack)obj).Name == Name)
|
||||
{ MsgPack = (MsgPack)obj; return true; }
|
||||
}
|
||||
}
|
||||
else if (type == typeof(object[]))
|
||||
{
|
||||
object[] Obj = (object[])Object;
|
||||
foreach (object obj in Obj)
|
||||
{
|
||||
if (obj == null) continue; type = obj.GetType();
|
||||
if (type == typeof(MsgPack)) if (((MsgPack)obj).Name == Name)
|
||||
{ MsgPack = (MsgPack)obj; return true; }
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public bool ContainsKey(string Name)
|
||||
{
|
||||
if (Object == null) return false;
|
||||
|
||||
Type type = Object.GetType();
|
||||
if (type == typeof(List<object>))
|
||||
{
|
||||
List<object> Obj = (List<object>)Object;
|
||||
foreach (object obj in Obj)
|
||||
{
|
||||
if (obj == null) continue; type = obj.GetType();
|
||||
if (type == typeof(MsgPack)) if (((MsgPack)obj).Name == Name) return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public enum Types : byte
|
||||
{
|
||||
PosInt = 0b00000000,
|
||||
FixMap = 0b10000000,
|
||||
FixArr = 0b10010000,
|
||||
FixStr = 0b10100000,
|
||||
Nil = 0b11000000,
|
||||
NeverUsed = 0b11000001,
|
||||
False = 0b11000010,
|
||||
True = 0b11000011,
|
||||
Bin8 = 0b11000100,
|
||||
Bin16 = 0b11000101,
|
||||
Bin32 = 0b11000110,
|
||||
Ext8 = 0b11000111,
|
||||
Ext16 = 0b11001000,
|
||||
Ext32 = 0b11001001,
|
||||
Float32 = 0b11001010,
|
||||
Float64 = 0b11001011,
|
||||
UInt8 = 0b11001100,
|
||||
UInt16 = 0b11001101,
|
||||
UInt32 = 0b11001110,
|
||||
UInt64 = 0b11001111,
|
||||
Int8 = 0b11010000,
|
||||
Int16 = 0b11010001,
|
||||
Int32 = 0b11010010,
|
||||
Int64 = 0b11010011,
|
||||
FixExt1 = 0b11010100,
|
||||
FixExt2 = 0b11010101,
|
||||
FixExt4 = 0b11010110,
|
||||
FixExt8 = 0b11010111,
|
||||
FixExt16 = 0b11011000,
|
||||
Str8 = 0b11011001,
|
||||
Str16 = 0b11011010,
|
||||
Str32 = 0b11011011,
|
||||
Arr16 = 0b11011100,
|
||||
Arr32 = 0b11011101,
|
||||
Map16 = 0b11011110,
|
||||
Map32 = 0b11011111,
|
||||
NegInt = 0b11100000,
|
||||
PosIntMax = 0b01111111,
|
||||
FixMapMax = 0b10001111,
|
||||
FixArrMax = 0b10011111,
|
||||
FixStrMax = 0b10111111,
|
||||
NegIntMax = 0b11111111,
|
||||
}
|
||||
|
||||
public struct Ext
|
||||
{
|
||||
public byte[] Data;
|
||||
public sbyte Type;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,327 @@
|
||||
//Original: https://github.com/blueskythlikesclouds/MikuMikuLibrary/
|
||||
|
||||
using KKdBaseLib;
|
||||
using KKdMainLib.IO;
|
||||
|
||||
namespace KKdMainLib
|
||||
{
|
||||
public struct Mot
|
||||
{
|
||||
private int i, i0, i1;
|
||||
private MotHeader[] MOT;
|
||||
private Stream IO;
|
||||
|
||||
public void MOTReader(string file)
|
||||
{
|
||||
IO = File.OpenReader(file + ".bin");
|
||||
|
||||
i = 0;
|
||||
while (true)
|
||||
if (IO.ReadInt64() == 0) break;
|
||||
else { IO.ReadInt64(); i++; }
|
||||
if (i == 0) return;
|
||||
|
||||
int MOTCount = i;
|
||||
MsgPack m = new MsgPack(MOTCount, "Mot");
|
||||
MOT = new MotHeader[MOTCount];
|
||||
for (i = 0; i < MOTCount; i++)
|
||||
{
|
||||
ref MotHeader Mot = ref MOT[i];
|
||||
Mot.KeySet .Offset = IO.ReadInt32();
|
||||
Mot.KeySetTypesOffset = IO.ReadInt32();
|
||||
Mot. KeySetOffset = IO.ReadInt32();
|
||||
Mot.BoneInfo .Offset = IO.ReadInt32();
|
||||
}
|
||||
|
||||
for (i = 0; i < MOTCount; i++)
|
||||
{
|
||||
ref MotHeader Mot = ref MOT[i];
|
||||
|
||||
i0 = 1;
|
||||
IO.Position = Mot.BoneInfo.Offset;
|
||||
IO.ReadUInt16();
|
||||
while (IO.ReadUInt16() != 0) i0++;
|
||||
|
||||
Mot.BoneInfo.Value = new BoneInfo[i0];
|
||||
IO.Position = Mot.BoneInfo.Offset;
|
||||
for (i0 = 0; i0 < Mot.BoneInfo.Value.Length; i0++)
|
||||
Mot.BoneInfo.Value[i0].Id = IO.ReadUInt16();
|
||||
|
||||
IO.Position = Mot.KeySet.Offset;
|
||||
int info = IO.ReadUInt16();
|
||||
Mot.HighBits = info >> 14;
|
||||
Mot.FrameCount = IO.ReadUInt16();
|
||||
|
||||
Mot.KeySet.Value = new KeySet[info & 0x3FFF];
|
||||
IO.Position = Mot.KeySetTypesOffset;
|
||||
for (i0 = 0; i0 < Mot.KeySet.Value.Length; i0++)
|
||||
{
|
||||
if (i0 % 8 == 0) i1 = IO.ReadUInt16();
|
||||
|
||||
Mot.KeySet.Value[i0] = new KeySet { Type = (KeySetType)((i1 >> (i0 % 8 * 2)) & 0b11) };
|
||||
}
|
||||
|
||||
IO.Position = Mot.KeySetOffset;
|
||||
for (i0 = 0; i0 < Mot.KeySet.Value.Length; i0++)
|
||||
{
|
||||
ref KeySet Key = ref Mot.KeySet.Value[i0];
|
||||
if (Key.Type == KeySetType.Static)
|
||||
{ Key.Keys = new KFT2<ushort, float>[1];
|
||||
Key.Keys[0].V = IO.ReadSingle(); }
|
||||
else if (Key.Type == KeySetType.Linear)
|
||||
{
|
||||
Key.Keys = new KFT2<ushort, float>[IO.ReadUInt16()];
|
||||
for (i1 = 0; i1 < Key.Keys.Length; i1++)
|
||||
Key.Keys[i1].F = IO.ReadUInt16();
|
||||
IO.Align(0x4);
|
||||
for (i1 = 0; i1 < Key.Keys.Length; i1++)
|
||||
Key.Keys[i1].V = IO.ReadSingle();
|
||||
}
|
||||
else if (Key.Type == KeySetType.Interpolated)
|
||||
{
|
||||
Key.Keys = new KFT2<ushort, float>[IO.ReadUInt16()];
|
||||
for (i1 = 0; i1 < Key.Keys.Length; i1++)
|
||||
Key.Keys[i].F = IO.ReadUInt16();
|
||||
IO.Align(0x4);
|
||||
for (i1 = 0; i1 < Key.Keys.Length; i1++)
|
||||
{ Key.Keys[i1].V = IO.ReadSingle(); Key.Keys[i1].T = IO.ReadSingle(); }
|
||||
}
|
||||
}
|
||||
}
|
||||
IO.Close();
|
||||
}
|
||||
|
||||
public void MOTWriter(string file)
|
||||
{
|
||||
if (MOT == null) return;
|
||||
IO = File.OpenWriter(file + ".bin");
|
||||
|
||||
int MOTCount = MOT.Length;
|
||||
IO.Position = (MOTCount + 1) << 4;
|
||||
for (i = 0; i < MOTCount; i++)
|
||||
{
|
||||
ref MotHeader Mot = ref MOT[i];
|
||||
Mot.KeySet.Offset = IO.Position;
|
||||
IO.Write((ushort)((Mot.HighBits << 14) | (Mot.KeySet.Value.Length & 0x3FFF)));
|
||||
IO.Write((ushort)Mot.FrameCount);
|
||||
|
||||
Mot.KeySetTypesOffset = IO.Position;
|
||||
for (i0 = 0, i1 = 0; i0 < Mot.KeySet.Value.Length; i0++)
|
||||
{
|
||||
i1 |= ((byte)Mot.KeySet.Value[i0].Type << (i0 % 8 * 2)) & (0b11 << (i0 % 8 * 2));
|
||||
|
||||
if (i0 % 8 == 7) { IO.Write((ushort)i1); i1 = 0; }
|
||||
}
|
||||
IO.Write((ushort)i1);
|
||||
|
||||
IO.Align(0x4);
|
||||
Mot.KeySetOffset = IO.Position;
|
||||
for (i0 = 0; i0 < Mot.KeySet.Value.Length; i0++)
|
||||
{
|
||||
ref KeySet Key = ref Mot.KeySet.Value[i0];
|
||||
if (Key.Type == KeySetType.Static)
|
||||
IO.Write(Key.Keys[0].V);
|
||||
else if (Key.Type == KeySetType.Linear)
|
||||
{
|
||||
IO.Write((ushort)Key.Keys.Length);
|
||||
for (i1 = 0; i1 < Key.Keys.Length; i1++)
|
||||
IO.Write(Key.Keys[i1].F);
|
||||
IO.Align(0x4);
|
||||
for (i1 = 0; i1 < Key.Keys.Length; i1++)
|
||||
IO.Write(Key.Keys[i1].V);
|
||||
}
|
||||
else if (Key.Type == KeySetType.Interpolated)
|
||||
{
|
||||
IO.Write((ushort)Key.Keys.Length);
|
||||
for (i1 = 0; i1 < Key.Keys.Length; i1++)
|
||||
IO.Write(Key.Keys[i1].F);
|
||||
IO.Align(0x4);
|
||||
for (i1 = 0; i1 < Key.Keys.Length; i1++)
|
||||
{ IO.Write(Key.Keys[i1].V); IO.Write(Key.Keys[i1].T); }
|
||||
}
|
||||
}
|
||||
IO.Align(0x4);
|
||||
|
||||
Mot.BoneInfo.Offset = IO.Position;
|
||||
for (i0 = 0; i0 < Mot.BoneInfo.Value.Length; i0++)
|
||||
IO.Write((ushort)Mot.BoneInfo.Value[i0].Id);
|
||||
IO.Write((ushort)0);
|
||||
}
|
||||
IO.Align(0x4, true);
|
||||
|
||||
IO.Position = 0;
|
||||
for (i = 0; i < MOTCount; i++)
|
||||
{
|
||||
ref MotHeader Mot = ref MOT[i];
|
||||
IO.Write(Mot.KeySet .Offset);
|
||||
IO.Write(Mot.KeySetTypesOffset);
|
||||
IO.Write(Mot. KeySetOffset);
|
||||
IO.Write(Mot.BoneInfo .Offset);
|
||||
}
|
||||
|
||||
IO.Close();
|
||||
}
|
||||
|
||||
public void MsgPackReader(string file, bool JSON)
|
||||
{
|
||||
MOT = null;
|
||||
|
||||
MsgPack MsgPack = file.ReadMP(JSON);
|
||||
if (!MsgPack.ElementArray("MOT", out MsgPack MOTS)) { MsgPack.Dispose(); return; }
|
||||
|
||||
if (MOTS.Array != null)
|
||||
if (MOTS.Array.Length > 0)
|
||||
{
|
||||
MOT = new MotHeader[MOTS.Array.Length];
|
||||
for (int i = 0; i < MOT.Length; i++)
|
||||
MsgPackReader(MOTS.Array[i], ref MOT[i]);
|
||||
}
|
||||
|
||||
MsgPack.Dispose();
|
||||
}
|
||||
|
||||
public void MsgPackWriter(string file, bool JSON)
|
||||
{
|
||||
int MOTCount = MOT.Length;
|
||||
MsgPack MOTS = new MsgPack(MOTCount, "MOT");
|
||||
for (i = 0; i < MOTCount; i++)
|
||||
MOTS[i] = MsgPackWriter(ref MOT[i]);
|
||||
MOTS.Write(true, file, JSON);
|
||||
}
|
||||
|
||||
public void MsgPackReader(MsgPack MOT, ref MotHeader Mot)
|
||||
{
|
||||
MsgPack Temp = MsgPack.New;
|
||||
Mot.HighBits = MOT.ReadInt32("HighBits" );
|
||||
Mot.FrameCount = MOT.ReadInt32("FrameCount");
|
||||
|
||||
if (!MOT.ElementArray("KeySets", out Temp)) return;
|
||||
|
||||
Mot.KeySet.Value = new KeySet[Temp.Array.Length];
|
||||
for (i0 = 0; i0 < Mot.KeySet.Value.Length; i0++)
|
||||
{
|
||||
ref KeySet KeySet = ref Mot.KeySet.Value[i0];
|
||||
|
||||
if (Temp.Array[i0].Array == null || Temp.Array[i0].Array.Length != 2) continue;
|
||||
KeySet.Type = (KeySetType)Temp.Array[i0].Array[0].ReadInt32();
|
||||
|
||||
MsgPack keySet = Temp.Array[i0].Array[1];
|
||||
|
||||
if (keySet.Array == null) { KeySet.Type = 0; continue; }
|
||||
else if (KeySet.Type == KeySetType.None) continue;
|
||||
else if (KeySet.Type == KeySetType.Static)
|
||||
{
|
||||
KeySet.Keys = new KFT2<ushort, float>[1];
|
||||
KeySet.Keys[0].F = keySet.Array[0][0].ReadUInt16();
|
||||
KeySet.Keys[0].V = keySet.Array[0][1].ReadSingle();
|
||||
}
|
||||
else if (KeySet.Type == KeySetType.Linear)
|
||||
{
|
||||
KeySet.Keys = new KFT2<ushort, float>[keySet.Array.Length];
|
||||
for (i1 = 0; i1 < keySet.Array.Length; i1++)
|
||||
{
|
||||
KeySet.Keys[i1].F = keySet.Array[i1][0].ReadUInt16();
|
||||
KeySet.Keys[i1].V = keySet.Array[i1][1].ReadSingle();
|
||||
}
|
||||
}
|
||||
else if (KeySet.Type == KeySetType.Interpolated)
|
||||
{
|
||||
KeySet.Keys = new KFT2<ushort, float>[keySet.Array.Length];
|
||||
for (i1 = 0; i1 < keySet.Array.Length; i1++)
|
||||
{
|
||||
KeySet.Keys[i1].F = keySet.Array[i1][0].ReadUInt16();
|
||||
KeySet.Keys[i1].V = keySet.Array[i1][1].ReadSingle();
|
||||
KeySet.Keys[i1].T = keySet.Array[i1][2].ReadSingle();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (MOT.ElementArray("BoneInfo", out Temp))
|
||||
{
|
||||
Mot.BoneInfo.Value = new BoneInfo[Temp.Array.Length];
|
||||
for (i = 0; i < Mot.BoneInfo.Value.Length; i++)
|
||||
Mot.BoneInfo.Value[i].Id = Temp[i].ReadInt32();
|
||||
}
|
||||
else return;
|
||||
}
|
||||
|
||||
public MsgPack MsgPackWriter(ref MotHeader Mot)
|
||||
{
|
||||
MsgPack MOT = MsgPack.NewReserve(4).Add("FrameCount", Mot.FrameCount).Add("HighBits", Mot.HighBits);
|
||||
|
||||
MsgPack KeySets = new MsgPack(Mot.KeySet.Value.Length, "KeySets");
|
||||
for (i0 = 0; i0 < Mot.KeySet.Value.Length; i0++)
|
||||
{
|
||||
ref KeySet KeySet = ref Mot.KeySet.Value[i0];
|
||||
if (KeySet.Type == KeySetType.None) continue;
|
||||
|
||||
KeySets[i0] = new MsgPack(2);
|
||||
KeySets[i0].Array[0] = (byte)KeySet.Type;
|
||||
KeySets[i0].Array[1] = new MsgPack(KeySet.Keys.Length);
|
||||
if (KeySet.Type == KeySetType.Static)
|
||||
{
|
||||
KeySets[i0].Array[1][0] = new MsgPack(2);
|
||||
KeySets[i0].Array[1][0].Array[0] = KeySet.Keys[0].F;
|
||||
KeySets[i0].Array[1][0].Array[1] = KeySet.Keys[0].V;
|
||||
}
|
||||
else if (KeySet.Type == KeySetType.Linear)
|
||||
for (i1 = 0; i1 < KeySet.Keys.Length; i1++)
|
||||
{
|
||||
KeySets[i0].Array[1][i1] = new MsgPack(2);
|
||||
KeySets[i0].Array[1][i1].Array[0] = KeySet.Keys[i1].F;
|
||||
KeySets[i0].Array[1][i1].Array[1] = KeySet.Keys[i1].V;
|
||||
}
|
||||
else
|
||||
for (i1 = 0; i1 < KeySet.Keys.Length; i1++)
|
||||
{
|
||||
KeySets[i0].Array[1][i1] = new MsgPack(3);
|
||||
KeySets[i0].Array[1][i1].Array[0] = KeySet.Keys[i1].F;
|
||||
KeySets[i0].Array[1][i1].Array[1] = KeySet.Keys[i1].V;
|
||||
KeySets[i0].Array[1][i1].Array[2] = KeySet.Keys[i1].T;
|
||||
}
|
||||
}
|
||||
MOT.Add(KeySets);
|
||||
|
||||
MsgPack BoneInfo = new MsgPack(Mot.BoneInfo.Value.Length, "BoneInfo");
|
||||
for (i0 = 0; i0 < Mot.BoneInfo.Value.Length; i0++)
|
||||
BoneInfo[i0] = Mot.BoneInfo.Value[i0].Id;
|
||||
MOT.Add(BoneInfo);
|
||||
|
||||
return MOT;
|
||||
}
|
||||
|
||||
public struct MotHeader
|
||||
{
|
||||
public int KeySetOffset;
|
||||
public int KeySetTypesOffset;
|
||||
public Pointer< KeySet []> KeySet ;
|
||||
public Pointer<BoneInfo[]> BoneInfo;
|
||||
|
||||
public int HighBits;
|
||||
public int FrameCount;
|
||||
}
|
||||
|
||||
public struct KeySet
|
||||
{
|
||||
public KFT2<ushort, float>[] Keys;
|
||||
public KeySetType Type;
|
||||
|
||||
public override string ToString() => $"Type: {Type}" + (Type == KeySetType.Static ?
|
||||
$"; Value: {Keys[0].Check()}" : Type > KeySetType.Static ? $"; Keys: {Keys.Length}" : "");
|
||||
}
|
||||
|
||||
public enum KeySetType : byte
|
||||
{
|
||||
None = 0b00,
|
||||
Static = 0b01,
|
||||
Linear = 0b10,
|
||||
Interpolated = 0b11,
|
||||
}
|
||||
|
||||
public struct BoneInfo
|
||||
{
|
||||
public string Name;
|
||||
public int Id;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,63 +0,0 @@
|
||||
using KKdMainLib.IO;
|
||||
|
||||
namespace KKdMainLib
|
||||
{
|
||||
public struct PDHead
|
||||
{
|
||||
public int ID;
|
||||
public int Lenght;
|
||||
public int DataSize;
|
||||
public int Signature;
|
||||
public int SectionSize;
|
||||
public int RealSignature;
|
||||
public Main.Format Format;
|
||||
public bool IsBE => Format == Main.Format.F2BE;
|
||||
public bool IsX => Format == Main.Format.X || Format == Main.Format.XHD;
|
||||
}
|
||||
|
||||
public static class PDHeadExtensions
|
||||
{
|
||||
public static PDHead ReadHeader(this Stream stream, bool Seek)
|
||||
{
|
||||
if (Seek)
|
||||
if (stream.Position >= 4) stream.Seek(-4, SeekOrigin.Current);
|
||||
else stream.Seek( 0, 0);
|
||||
return stream.ReadHeader();
|
||||
}
|
||||
|
||||
public static PDHead ReadHeader(this Stream stream)
|
||||
{
|
||||
long Position = stream.LongPosition;
|
||||
PDHead Header = new PDHead
|
||||
{ Format = Main.Format.F2LE, Signature = stream.ReadInt32(),
|
||||
DataSize = stream.ReadInt32(), Lenght = stream.ReadInt32() };
|
||||
if (stream.ReadUInt32() == 0x18000000)
|
||||
{ Header.Format = Main.Format.F2BE; }
|
||||
Header.ID = stream.ReadInt32();
|
||||
Header.SectionSize = stream.ReadInt32();
|
||||
stream.IsBE = Header.Format == Main.Format.F2BE;
|
||||
stream.Format = Header.Format;
|
||||
stream.LongPosition = Position + Header.Lenght;
|
||||
Header.Signature = stream.ReadInt32Endian();
|
||||
return Header;
|
||||
}
|
||||
|
||||
public static void Write(this Stream stream, PDHead Header)
|
||||
{
|
||||
stream.Write(Header.Signature);
|
||||
stream.Write(Header.DataSize);
|
||||
stream.Write(Header.Lenght);
|
||||
if (Header.Format == Main.Format.F2BE) stream.Write(0x18000000);
|
||||
else stream.Write(0x10000000);
|
||||
stream.Write(Header.ID);
|
||||
stream.Write(Header.SectionSize);
|
||||
stream.Write(0x00);
|
||||
stream.Write(0x00);
|
||||
}
|
||||
|
||||
public static void WriteEOFC(this Stream stream, int ID)
|
||||
{ PDHead Header = new PDHead { Format = Main.Format.F2LE, ID = ID,
|
||||
Lenght = 0x20, Signature = 0x43464F45, }; stream.Write(Header); }
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,131 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using KKdMainLib.IO;
|
||||
|
||||
namespace KKdMainLib
|
||||
{
|
||||
public class POF
|
||||
{
|
||||
public byte Type;
|
||||
public int Lenght;
|
||||
public int Offset;
|
||||
public int LastOffset;
|
||||
public List<long> Offsets;
|
||||
public List<long> POFOffsets;
|
||||
public PDHead Header;
|
||||
|
||||
public POF()
|
||||
{ Type = 0; Lenght = 0; Offset = 0; LastOffset = 0; Offsets = new List<long>();
|
||||
POFOffsets = new List<long>(); Header = new PDHead(); }
|
||||
}
|
||||
|
||||
public static class POFExtensions
|
||||
{
|
||||
public static POF AddPOF(this PDHead Header)
|
||||
{
|
||||
POF POF = new POF { Offsets = new List<long>(), POFOffsets =
|
||||
new List<long>(), Offset = Header.DataSize + Header.Lenght };
|
||||
return POF;
|
||||
}
|
||||
public static Stream GetOffset(this Stream stream, ref POF POF)
|
||||
{
|
||||
if (POF != null) if (stream.Format > Main.Format.F)
|
||||
POF.POFOffsets.Add(stream.Position - (stream.IsX ? stream.Offset : 0x00));
|
||||
return stream;
|
||||
}
|
||||
|
||||
public static void ReadPOF(this Stream stream, ref POF POF)
|
||||
{
|
||||
if (stream.ReadString(3) == "POF")
|
||||
{
|
||||
POF.POFOffsets.Sort();
|
||||
POF.Type = byte.Parse(stream.ReadString(1));
|
||||
int IsX = POF.Type + 2;
|
||||
stream.Seek(-4, SeekOrigin.Current);
|
||||
POF.Header = stream.ReadHeader();
|
||||
stream.Seek(POF.Offset + POF.Header.Lenght, 0);
|
||||
POF.Lenght = stream.ReadInt32();
|
||||
while (POF.Lenght + POF.Offset + POF.Header.Lenght > stream.Position)
|
||||
{
|
||||
int a = stream.ReadByte();
|
||||
if (a >> 6 == 0) break;
|
||||
else if (a >> 6 == 1) a = a & 0x3F;
|
||||
else if (a >> 6 == 2)
|
||||
{
|
||||
a = a & 0x3F;
|
||||
a = (a << 8) | stream.ReadByte();
|
||||
}
|
||||
else if (a >> 6 == 3)
|
||||
{
|
||||
a = a & 0x3F;
|
||||
a = (a << 8) | stream.ReadByte();
|
||||
a = (a << 8) | stream.ReadByte();
|
||||
a = (a << 8) | stream.ReadByte();
|
||||
}
|
||||
a <<= IsX;
|
||||
POF.LastOffset += a;
|
||||
POF.Offsets.Add(POF.LastOffset);
|
||||
}
|
||||
|
||||
for (int i = 0; i < POF.Offsets.Count && i < POF.POFOffsets.Count; i++)
|
||||
if (POF.Offsets[i] != POF.POFOffsets[i])
|
||||
Console.WriteLine("Not right POF{0} offset table.\n" +
|
||||
" Expected: {1}\n Got: {2}", POF.Type,
|
||||
POF.Offsets[i].ToString("X8"), POF.POFOffsets[i].ToString("X8"));
|
||||
}
|
||||
}
|
||||
|
||||
public static void Write(this Stream stream, ref POF POF, int ID)
|
||||
{
|
||||
POF.POFOffsets.Sort();
|
||||
long CurrentPOFOffset = 0;
|
||||
long POFOffset = 0;
|
||||
byte BitShift = (byte)(2 + POF.Type);
|
||||
int Max1 = (0x00FF >> BitShift) << BitShift;
|
||||
int Max2 = (0xFFFF >> BitShift) << BitShift;
|
||||
POF.Lenght = 5 + ID;
|
||||
for (int i = 0; i < POF.POFOffsets.Count; i++)
|
||||
{
|
||||
POFOffset = POF.POFOffsets[i] - CurrentPOFOffset;
|
||||
CurrentPOFOffset = POF.POFOffsets[i];
|
||||
if (POFOffset <= Max1) POF.Lenght += 1;
|
||||
else if (POFOffset <= Max2) POF.Lenght += 2;
|
||||
else POF.Lenght += 4;
|
||||
POF.POFOffsets[i] = POFOffset;
|
||||
}
|
||||
|
||||
long POFLenghtAling = POF.Lenght.Align(16);
|
||||
POF.Header = new PDHead { DataSize = (int)POFLenghtAling, ID = ID, Format = Main.Format.F2LE,
|
||||
Lenght = 0x20, SectionSize = (int)POFLenghtAling, Signature = 0x30464F50 };
|
||||
POF.Header.Signature += POF.Type << 24;
|
||||
stream.Write(POF.Header);
|
||||
|
||||
stream.Write(POF.Lenght);
|
||||
for (int i = 0; i < POF.POFOffsets.Count; i++)
|
||||
{
|
||||
POFOffset = POF.POFOffsets[i];
|
||||
if (POFOffset <= Max1) stream.Write (( byte)((1 << 6) | (POFOffset >> BitShift)));
|
||||
else if (POFOffset <= Max2) stream.WriteEndian((ushort)((2 << 14) | (POFOffset >> BitShift)), true);
|
||||
else stream.WriteEndian(( uint)((3 << 30) | (POFOffset >> BitShift)), true);
|
||||
}
|
||||
stream.Write(0x00);
|
||||
stream.Align(16, true);
|
||||
stream.WriteEOFC(ID);
|
||||
}
|
||||
|
||||
public static long ReadUInt32Endian(this Stream IO, ref POF POF) =>
|
||||
IO.GetOffset(ref POF).ReadUInt32Endian();
|
||||
public static long ReadUInt32Endian(this Stream IO, ref POF POF, bool IsBE) =>
|
||||
IO.GetOffset(ref POF).ReadUInt32Endian(IsBE);
|
||||
public static long ReadInt64(this Stream IO, ref POF POF) =>
|
||||
IO.GetOffset(ref POF).ReadInt64();
|
||||
|
||||
public static long ReadIntX(this Stream IO, ref POF POF ) =>
|
||||
IO.IsX ? IO.ReadInt64() : IO.ReadUInt32Endian( );
|
||||
public static long ReadIntX(this Stream IO, ref POF POF, bool IsBE) =>
|
||||
IO.IsX ? IO.ReadInt64() : IO.ReadUInt32Endian(IsBE);
|
||||
|
||||
public static string ReadStringAtOffset(this Stream IO, ref POF POF, long Offset = 0, long Length = 0) =>
|
||||
IO.GetOffset(ref POF).ReadStringAtOffset(Offset, Length);
|
||||
}
|
||||
}
|
||||
@@ -2,14 +2,14 @@
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
[assembly: AssemblyTitle("KKdMainLib")]
|
||||
[assembly: AssemblyDescription("")]
|
||||
[assembly: AssemblyDescription("A simple library for working with Project Diva AC/DT/F/AFT/F2/X/FT files")]
|
||||
[assembly: AssemblyConfiguration("")]
|
||||
[assembly: AssemblyCompany("")]
|
||||
[assembly: AssemblyProduct("KKdMainLib")]
|
||||
[assembly: AssemblyCopyright("Copyright korenkonder © 2018-2019")]
|
||||
[assembly: AssemblyCopyright("korenkonder © 2018-2019")]
|
||||
[assembly: AssemblyTrademark("")]
|
||||
[assembly: AssemblyCulture("")]
|
||||
[assembly: ComVisible(false)]
|
||||
[assembly: Guid("2BA7EFC6-91D1-8BBC-C487-06C7F36CC789")]
|
||||
[assembly: AssemblyVersion("0.4.5.9")]
|
||||
[assembly: AssemblyFileVersion("0.4.5.9")]
|
||||
[assembly: AssemblyVersion("0.4.7.4")]
|
||||
[assembly: AssemblyFileVersion("0.4.7.4")]
|
||||
|
||||
+126
-122
@@ -1,212 +1,216 @@
|
||||
using System;
|
||||
using System.Xml.Linq;
|
||||
using System.Collections.Generic;
|
||||
using KKdBaseLib;
|
||||
using KKdBaseLib.F2;
|
||||
using KKdMainLib.IO;
|
||||
using KKdMainLib.MessagePack;
|
||||
using MPIO = KKdMainLib.MessagePack.IO;
|
||||
|
||||
namespace KKdMainLib
|
||||
{
|
||||
public class STR
|
||||
{
|
||||
public struct String
|
||||
{
|
||||
public int ID;
|
||||
public int StrOffset;
|
||||
public string Str;
|
||||
}
|
||||
|
||||
public STR()
|
||||
{ Offset = 0; OffsetX = 0; STRs = null; POF = null; Header = new PDHead(); }
|
||||
{ Offset = 0; OffsetX = 0; STRs = null; Header = new Header(); }
|
||||
|
||||
private long Offset;
|
||||
private long OffsetX;
|
||||
public String[] STRs;
|
||||
private POF POF;
|
||||
private PDHead Header;
|
||||
private Header Header;
|
||||
private Stream IO;
|
||||
|
||||
public String[] STRs;
|
||||
|
||||
public int STRReader(string filepath, string ext)
|
||||
{
|
||||
Stream reader = File.OpenReader(filepath + ext);
|
||||
IO = File.OpenReader(filepath + ext);
|
||||
|
||||
Header = new PDHead();
|
||||
reader.Format = Main.Format.F;
|
||||
Header.Signature = reader.ReadInt32();
|
||||
Header = new Header();
|
||||
IO.Format = Format.F;
|
||||
Header.Signature = IO.ReadInt32();
|
||||
if (Header.Signature == 0x41525453)
|
||||
{
|
||||
Header = reader.ReadHeader(true);
|
||||
POF = Header.AddPOF();
|
||||
reader.Position = Header.Lenght;
|
||||
Header = IO.ReadHeader(true, false);
|
||||
POF.Offsets = KKdList<long>.New;
|
||||
|
||||
long Count = reader.ReadInt32Endian();
|
||||
Offset = reader.ReadInt32Endian();
|
||||
long Count = IO.ReadInt32Endian();
|
||||
Offset = IO.ReadInt32Endian();
|
||||
|
||||
if (Offset == 0)
|
||||
{
|
||||
Offset = Count;
|
||||
OffsetX = reader.ReadInt64();
|
||||
Count = reader.ReadInt64();
|
||||
reader.Offset = Header.Lenght;
|
||||
reader.Format = Main.Format.X;
|
||||
OffsetX = IO.ReadInt64();
|
||||
Count = IO.ReadInt64();
|
||||
IO.Offset = Header.Length;
|
||||
IO.Format = Format.X;
|
||||
IO.LongOffset += Offset;
|
||||
IO.Position = 0;
|
||||
}
|
||||
reader.LongPosition = reader.IsX ? Offset + reader.Offset : Offset;
|
||||
else IO.Position = Header.Length + 0x40;
|
||||
|
||||
STRs = new String[Count];
|
||||
for (int i = 0; i < Count; i++)
|
||||
{
|
||||
STRs[i].StrOffset = reader.GetOffset(ref POF).ReadInt32Endian();
|
||||
STRs[i].ID = reader.ReadInt32Endian();
|
||||
if (reader.IsX) STRs[i].StrOffset += (int)OffsetX;
|
||||
STRs[i].Str.Offset = IO.ReadInt32Endian();
|
||||
STRs[i].ID = IO.ReadInt32Endian();
|
||||
}
|
||||
|
||||
for (int i = 0; i < Count; i++)
|
||||
if (IO.IsX)
|
||||
{
|
||||
reader.LongPosition = STRs[i].StrOffset + (reader.IsX ? reader.Offset : 0);
|
||||
STRs[i].Str = reader.NullTerminatedUTF8();
|
||||
IO.LongOffset = Header.Length + OffsetX;
|
||||
for (int i = 0; i < Count; i++)
|
||||
STRs[i].Str.Value = IO.ReadStringAtOffset(STRs[i].Str.Offset);
|
||||
}
|
||||
else
|
||||
{
|
||||
IO.Offset = 0;
|
||||
for (int i = 0; i < Count; i++)
|
||||
STRs[i].Str.Value = STRs[i].Str.Offset > 0 ?
|
||||
IO.ReadStringAtOffset(STRs[i].Str.Offset) : null;
|
||||
}
|
||||
|
||||
reader.Position = POF.Offset;
|
||||
reader.ReadPOF(ref POF);
|
||||
}
|
||||
else
|
||||
{
|
||||
reader.Position -= 4;
|
||||
IO.Position -= 4;
|
||||
int Count = 0;
|
||||
for (int a = 0, i = 0; reader.Position > 0 && reader.Position < reader.Length; i++, Count++)
|
||||
for (int a = 0, i = 0; IO.Position > 0 && IO.Position < IO.Length; i++, Count++)
|
||||
{
|
||||
a = reader.ReadInt32();
|
||||
a = IO.ReadInt32();
|
||||
if (a == 0) break;
|
||||
}
|
||||
STRs = new String[Count];
|
||||
|
||||
for (int i = 0; i < Count; i++)
|
||||
{
|
||||
reader.LongPosition = STRs[i].StrOffset + (reader.IsX ? reader.Offset : 0);
|
||||
STRs[i].ID = i;
|
||||
STRs[i].Str = reader.NullTerminatedUTF8();
|
||||
IO.LongPosition = STRs[i].Str.Offset;
|
||||
STRs[i].ID = i;
|
||||
STRs[i].Str.Value = IO.NullTerminatedUTF8();
|
||||
}
|
||||
}
|
||||
|
||||
reader.Close();
|
||||
IO.Close();
|
||||
return 1;
|
||||
}
|
||||
|
||||
public void STRWriter(string filepath)
|
||||
{
|
||||
if (STRs == null || STRs.Length == 0 || Header.Format > Format.F2BE) return;
|
||||
uint Offset = 0;
|
||||
uint CurrentOffset = 0;
|
||||
Stream writer = File.OpenWriter(filepath + (Header.
|
||||
Format > Main.Format.FT ? ".str" : ".bin"), true);
|
||||
writer.Format = Header.Format;
|
||||
POF = new POF();
|
||||
writer.IsBE = writer.Format == Main.Format.F2BE;
|
||||
IO = File.OpenWriter(filepath + (Header.Format > Format.FT ? ".str" : ".bin"), true);
|
||||
IO.Format = Header.Format;
|
||||
POF.Offsets = KKdList<long>.New;
|
||||
IO.IsBE = IO.Format == Format.F2BE;
|
||||
|
||||
long Count = STRs.LongLength;
|
||||
if (writer.Format > Main.Format.FT)
|
||||
if (IO.Format > Format.FT)
|
||||
{
|
||||
writer.Position = 0x40;
|
||||
writer.WriteEndian(Count);
|
||||
writer.GetOffset(ref POF).WriteEndian(0x80);
|
||||
writer.Position = 0x80;
|
||||
for (int i = 0; i < Count; i++)
|
||||
{
|
||||
writer.GetOffset(ref POF).Write(0x00);
|
||||
writer.WriteEndian(STRs[i].ID);
|
||||
}
|
||||
writer.Align(16);
|
||||
IO.Position = 0x40;
|
||||
IO.WriteX(Count, ref POF);
|
||||
IO.WriteX(0x80);
|
||||
IO.Position = 0x80;
|
||||
for (int i = 0; i < Count; i++) IO.Write(0x00L);
|
||||
IO.Align(0x10);
|
||||
}
|
||||
else
|
||||
{
|
||||
for (int i = 0; i < Count; i++)
|
||||
writer.Write(0x00);
|
||||
writer.Align(32);
|
||||
for (int i = 0; i < Count; i++) IO.Write(0x00);
|
||||
IO.Align(0x20);
|
||||
}
|
||||
|
||||
List<string> UsedSTR = new List<string>();
|
||||
List<int> UsedSTRPos = new List<int>();
|
||||
KKdList<string> UsedSTR = KKdList<string>.New;
|
||||
KKdList<int> UsedSTRPos = KKdList<int>.New;
|
||||
int[] STRPos = new int[Count];
|
||||
for (int i1 = 0; i1 < Count; i1++)
|
||||
|
||||
UsedSTRPos.Add(IO.Position);
|
||||
UsedSTR.Add("");
|
||||
IO.WriteByte(0);
|
||||
for (int i = 0; i < Count; i++)
|
||||
{
|
||||
if (UsedSTR.Contains(STRs[i1].Str))
|
||||
if (!UsedSTR.Contains(STRs[i].Str.Value))
|
||||
{
|
||||
for (int i2 = 0; i2 < Count; i2++)
|
||||
if (UsedSTR[i2] == STRs[i1].Str)
|
||||
{ STRPos[i1] = UsedSTRPos[i2]; break; }
|
||||
STRPos[i] = IO.Position;
|
||||
UsedSTRPos.Add(STRPos[i]);
|
||||
UsedSTR.Add(STRs[i].Str.Value);
|
||||
IO.Write(STRs[i].Str.Value);
|
||||
IO.WriteByte(0);
|
||||
}
|
||||
else
|
||||
{
|
||||
STRPos[i1] = writer.Position;
|
||||
UsedSTRPos.Add(STRPos[i1]);
|
||||
UsedSTR.Add(STRs[i1].Str);
|
||||
writer.Write(STRs[i1].Str);
|
||||
writer.WriteByte(0);
|
||||
}
|
||||
}
|
||||
if (writer.Format > Main.Format.FT)
|
||||
{
|
||||
writer.Align(16);
|
||||
Offset = writer.UIntPosition;
|
||||
writer.Position = 0x80;
|
||||
}
|
||||
else
|
||||
writer.Position = 0;
|
||||
for (int i1 = 0; i1 < Count; i1++)
|
||||
{
|
||||
writer.WriteEndian(STRPos[i1]);
|
||||
if (writer.Format > Main.Format.FT) writer.Position += 4;
|
||||
for (int i2 = 0; i2 < Count; i2++)
|
||||
if (UsedSTR[i2] == STRs[i].Str.Value) { STRPos[i] = UsedSTRPos[i2]; break; }
|
||||
}
|
||||
|
||||
if (writer.Format > Main.Format.FT)
|
||||
if (IO.Format > Format.FT)
|
||||
{
|
||||
writer.UIntPosition = Offset;
|
||||
writer.Write(ref POF, 1);
|
||||
CurrentOffset = writer.UIntPosition;
|
||||
writer.WriteEOFC(0);
|
||||
Header.Lenght = 0x40;
|
||||
Header.DataSize = (int)(CurrentOffset - Header.Lenght);
|
||||
IO.Align(0x10);
|
||||
Offset = IO.UIntPosition;
|
||||
IO.Position = 0x80;
|
||||
for (int i = 0; i < Count; i++)
|
||||
{
|
||||
POF.Offsets.Add(IO.Position);
|
||||
IO.WriteEndian(STRPos[i]);
|
||||
IO.WriteEndian(STRs[i].ID);
|
||||
}
|
||||
|
||||
IO.UIntPosition = Offset;
|
||||
POF.ID = 1;
|
||||
IO.Write(POF);
|
||||
CurrentOffset = IO.UIntPosition;
|
||||
IO.WriteEOFC();
|
||||
Header.DataSize = (int)(CurrentOffset - 0x40);
|
||||
Header.Signature = 0x41525453;
|
||||
Header.SectionSize = (int)(Offset - Header.Lenght);
|
||||
writer.Position = 0;
|
||||
writer.Write(Header);
|
||||
Header.SectionSize = (int)(Offset - 0x40);
|
||||
IO.Position = 0;
|
||||
IO.Write(Header, true);
|
||||
}
|
||||
writer.Close();
|
||||
else
|
||||
{
|
||||
IO.Position = 0;
|
||||
for (int i = 0; i < Count; i++) IO.Write(STRPos[i]);
|
||||
}
|
||||
IO.Close();
|
||||
}
|
||||
|
||||
public void MsgPackReader(string file, bool JSON)
|
||||
{
|
||||
MsgPack MsgPack = file.ReadMP(JSON);
|
||||
MsgPack MsgPack = file.ReadMPAllAtOnce(JSON);
|
||||
if (!MsgPack.Element("STR", out MsgPack STR)) return;
|
||||
Header = new Header();
|
||||
System.Enum.TryParse(STR.ReadString("Format"), out Header.Format);
|
||||
|
||||
if (MsgPack.Element("STR", out MsgPack STR))
|
||||
if (!STR.ElementArray("Strings", out MsgPack Strings)) return;
|
||||
|
||||
STRs = new String[Strings.Array.Length];
|
||||
for (int i = 0; i < STRs.Length; i++)
|
||||
{
|
||||
if (STR.Element("Strings", out MsgPack Strings, typeof(object[])))
|
||||
{
|
||||
STRs = new String[((object[])Strings.Object).Length];
|
||||
MsgPack String;
|
||||
for (int i = 0; i < STRs.Length; i++)
|
||||
if (Strings[i].GetType() == typeof(MsgPack))
|
||||
{
|
||||
String = (MsgPack)Strings[i];
|
||||
STRs[i].ID = String.ReadInt32 ("ID" );
|
||||
STRs[i].Str = String.ReadString("Str");
|
||||
}
|
||||
}
|
||||
STRs[i].ID = Strings[i].ReadInt32 ("ID" );
|
||||
STRs[i].Str.Value = Strings[i].ReadString("Str");
|
||||
if (STRs[i].Str.Value == null) STRs[i].Str.Value = "";
|
||||
}
|
||||
MsgPack = null;
|
||||
|
||||
MsgPack.Dispose();
|
||||
}
|
||||
|
||||
public void MsgPackWriter(string file, bool JSON)
|
||||
{
|
||||
if (STRs == null || STRs.Length == 0) return;
|
||||
MsgPack STR_ = new MsgPack("STR").Add("Format", Header.Format.ToString());
|
||||
MsgPack Strings = new MsgPack("Strings", STRs.Length);
|
||||
MsgPack Strings = new MsgPack(STRs.Length, "Strings");
|
||||
for (int i = 0; i < STRs.Length; i++)
|
||||
{
|
||||
Strings[i] = new MsgPack().Add("ID", STRs[i].ID);
|
||||
if (STRs[i].Str != null) if (STRs[i].Str != "")
|
||||
((MsgPack)Strings[i]).Add("S", STRs[i].Str); ;
|
||||
Strings[i] = MsgPack.New.Add("ID", STRs[i].ID);
|
||||
if (STRs[i].Str.Value != null)
|
||||
if (STRs[i].Str.Value != "")
|
||||
Strings[i] = Strings[i].Add("Str", STRs[i].Str.Value);
|
||||
}
|
||||
STR_.Add(Strings);
|
||||
|
||||
STR_.Write(true, file, JSON);
|
||||
STR_.WriteAfterAll(true, file, JSON);
|
||||
}
|
||||
|
||||
public struct String
|
||||
{
|
||||
public int ID;
|
||||
public Pointer<string> Str;
|
||||
|
||||
public override string ToString() => "ID: " + ID + (Str.Value != null ||
|
||||
Str.Value != "" ? ("; Str: " + Str.Value) : "");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,17 +0,0 @@
|
||||
using System;
|
||||
using System.Text;
|
||||
|
||||
namespace KKdMainLib
|
||||
{
|
||||
public static class Text
|
||||
{
|
||||
public static string ToASCII(this byte[] Array) => Encoding.ASCII.GetString(Array);
|
||||
public static string ToUTF8 (this byte[] Array) => Encoding.UTF8 .GetString(Array);
|
||||
public static byte[] ToASCII(this string Data ) => Encoding.ASCII.GetBytes (Data );
|
||||
public static byte[] ToUTF8 (this string Data ) => Encoding.UTF8 .GetBytes (Data );
|
||||
public static byte[] ToASCII(this char[] Data ) => Encoding.ASCII.GetBytes (Data );
|
||||
public static byte[] ToUTF8 (this char[] Data ) => Encoding.UTF8 .GetBytes (Data );
|
||||
public static string ToBase64(this byte[] Array) => Convert. ToBase64String(Array);
|
||||
public static byte[] FromBase64(this string Data ) => Convert.FromBase64String(Data );
|
||||
}
|
||||
}
|
||||
@@ -1,102 +0,0 @@
|
||||
using System;
|
||||
|
||||
namespace KKdMainLib.Types
|
||||
{
|
||||
public struct Half : IFormattable
|
||||
{
|
||||
private ushort _value;
|
||||
|
||||
public static explicit operator Half(ushort bits) => new Half() { _value = bits };
|
||||
|
||||
public static explicit operator ushort(Half bits) => bits._value;
|
||||
|
||||
public static explicit operator double(Half h)
|
||||
{
|
||||
if (h._value == 0x0000)
|
||||
return +0;
|
||||
else if (h._value == 0x8000)
|
||||
return (-0);
|
||||
else if (h._value == 0x7C00)
|
||||
return double.PositiveInfinity;
|
||||
else if (h._value == 0xFC00)
|
||||
return double.NegativeInfinity;
|
||||
else if (h._value >> 10 == 0x1F)
|
||||
return double.NaN;
|
||||
else if (h._value >> 10 == 0x3F)
|
||||
return -double.NaN;
|
||||
|
||||
long exponent = ((h._value >> 10) & 0x1F);
|
||||
long mantissa = (h._value & 0x3FF);
|
||||
sbyte n = (sbyte)(((h._value >> 15 & 0x01) == 0) ? 1 : -1);
|
||||
|
||||
double m = (((long)1 << 10) | mantissa) / Math.Pow(2, 10);
|
||||
double x = Math.Pow(2, exponent - (0x1F >> 1));
|
||||
double d = n * m * x;
|
||||
return d;
|
||||
}
|
||||
|
||||
public static explicit operator Half(double val)
|
||||
{
|
||||
Half h = new Half();
|
||||
if (val == +0)
|
||||
h._value = 0x0000;
|
||||
else if (val == -0)
|
||||
h._value = 0x8000;
|
||||
else if (val == double.NaN)
|
||||
h._value = 0x7FFF;
|
||||
else if (val == -double.NaN)
|
||||
h._value = 0xFFFF;
|
||||
else if (val == double.PositiveInfinity)
|
||||
h._value = 0x7C00;
|
||||
else if (val == double.NegativeInfinity)
|
||||
h._value = 0xFC00;
|
||||
else
|
||||
h._value = ToDouble(val);
|
||||
return h;
|
||||
}
|
||||
|
||||
public static ushort ToDouble(double val)
|
||||
{
|
||||
ushort Sign = 0;
|
||||
if (val < 0)
|
||||
Sign = 0x8000;
|
||||
val = Math.Abs(val);
|
||||
double Pow1 = 1;
|
||||
double Pow2 = 1 << 10;
|
||||
double x = 0;
|
||||
|
||||
int MaxPow = (1 << 4);
|
||||
|
||||
int i = 0;
|
||||
while (i < MaxPow && i > -MaxPow + 1)
|
||||
{
|
||||
Pow1 = Math.Pow(2, i);
|
||||
x = val / Pow1;
|
||||
if (x >= 1 && x < 2)
|
||||
{
|
||||
ushort exponent_max = (ushort)Math.Ceiling(x * Pow2);
|
||||
ushort exponent_min = (ushort)Math.Floor (x * Pow2);
|
||||
ushort exponent = 0;
|
||||
if (Math.Abs(x - exponent_max / Pow2) > Math.Abs(x - exponent_min / Pow2))
|
||||
exponent = exponent_max;
|
||||
else exponent = exponent_min;
|
||||
ushort mantissa = (ushort)(i + MaxPow - 1);
|
||||
ushort d = (ushort)(Sign | ((mantissa & 0x001F) << 10) | (exponent & 0x03FF));
|
||||
return d;
|
||||
}
|
||||
else if (val < 1) i--;
|
||||
else i++;
|
||||
}
|
||||
|
||||
if (i >= +0)
|
||||
return 0x7C00;
|
||||
else
|
||||
return 0xFC00;
|
||||
}
|
||||
|
||||
public override string ToString() => ((double)this).ToString();
|
||||
public string ToString(string format, IFormatProvider formatProvider) =>
|
||||
((double)this).ToString(format, formatProvider);
|
||||
public override int GetHashCode() => base.GetHashCode();
|
||||
}
|
||||
}
|
||||
@@ -1,21 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using KKdMainLib.MessagePack;
|
||||
|
||||
namespace KKdMainLib.Types
|
||||
{
|
||||
public class Vector2<T>
|
||||
{
|
||||
public T X;
|
||||
public T Y;
|
||||
public T Z;
|
||||
|
||||
public Vector2()
|
||||
{ X = default(T); Y = default(T); Z = default(T); }
|
||||
|
||||
public Vector2(T X, T Y, T Z)
|
||||
{ this.X = X; this.Y = Y; this.Z = Z; }
|
||||
}
|
||||
}
|
||||
@@ -1,21 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using KKdMainLib.MessagePack;
|
||||
|
||||
namespace KKdMainLib.Types
|
||||
{
|
||||
public class Vector3<T>
|
||||
{
|
||||
public T X;
|
||||
public T Y;
|
||||
public T Z;
|
||||
|
||||
public Vector3()
|
||||
{ X = default(T); Y = default(T); Z = default(T); }
|
||||
|
||||
public Vector3(T X, T Y, T Z)
|
||||
{ this.X = X; this.Y = Y; this.Z = Z; }
|
||||
}
|
||||
}
|
||||
@@ -1,102 +0,0 @@
|
||||
using System;
|
||||
using System.Xml;
|
||||
using System.Text;
|
||||
using System.Xml.Linq;
|
||||
|
||||
namespace KKdMainLib
|
||||
{
|
||||
public class Xml
|
||||
{
|
||||
public XDocument doc;
|
||||
|
||||
public bool Compact = false;
|
||||
|
||||
public Xml() { doc = new XDocument(); }
|
||||
|
||||
public void OpenXml(string file, bool compact)
|
||||
{
|
||||
doc = XDocument.Load(file);
|
||||
Compact = compact;
|
||||
}
|
||||
|
||||
public void SaveXml(string file)
|
||||
{
|
||||
XmlWriter writer = XmlWriter.Create(file, settings);
|
||||
doc.Save(writer);
|
||||
writer.Dispose();
|
||||
Compact = false;
|
||||
GC.Collect();
|
||||
}
|
||||
|
||||
public readonly XmlWriterSettings settings = new XmlWriterSettings
|
||||
{ Encoding = Encoding.UTF8, NewLineChars = "\n", Indent = true, IndentChars = "\t" };
|
||||
|
||||
public void Reader(XElement Child, ref bool value, string localName)
|
||||
{ if (Child.Name == localName) value = bool.Parse(Child.Value); }
|
||||
|
||||
public void Reader(XAttribute Entry, ref bool value, string localName)
|
||||
{ if (Entry.Name == localName) value = bool.Parse(Entry.Value); }
|
||||
|
||||
public void Reader(XElement Child, ref int value, string localName)
|
||||
{ if (Child.Name == localName) value = int.Parse(Child.Value); }
|
||||
|
||||
public void Reader(XAttribute Entry, ref int value, string localName)
|
||||
{ if (Entry.Name == localName) value = int.Parse(Entry.Value); }
|
||||
|
||||
public void Reader(XElement Child, ref uint value, string localName)
|
||||
{ if (Child.Name == localName) value = uint.Parse(Child.Value); }
|
||||
|
||||
public void Reader(XAttribute Entry, ref uint value, string localName)
|
||||
{ if (Entry.Name == localName) value = uint.Parse(Entry.Value); }
|
||||
|
||||
public void Reader(XElement Child, ref long value, string localName)
|
||||
{ if (Child.Name == localName) value = long.Parse(Child.Value); }
|
||||
|
||||
public void Reader(XAttribute Entry, ref long value, string localName)
|
||||
{ if (Entry.Name == localName) value = long.Parse(Entry.Value); }
|
||||
|
||||
public void Reader(XElement Child, ref ulong value, string localName)
|
||||
{ if (Child.Name == localName) value = ulong.Parse(Child.Value); }
|
||||
|
||||
public void Reader(XAttribute Entry, ref ulong value, string localName)
|
||||
{ if (Entry.Name == localName) value = ulong.Parse(Entry.Value); }
|
||||
|
||||
public void Reader(XElement Child, ref double value, string localName)
|
||||
{ if (Child.Name == localName) value = Child.Value.ToDouble(); }
|
||||
|
||||
public void Reader(XAttribute Entry, ref double value, string localName)
|
||||
{ if (Entry.Name == localName) value = Entry.Value.ToDouble(); }
|
||||
|
||||
public void Reader(XElement Child, ref string value, string localName)
|
||||
{ if (Child.Name == localName) value = Child.Value; }
|
||||
|
||||
public void Reader(XAttribute Entry, ref string value, string localName)
|
||||
{ if (Entry.Name == localName) value = Entry.Value; }
|
||||
|
||||
public void Reader(XElement Child, ref string[] value, string localName, params char[] Separate)
|
||||
{ if (Child.Name == localName) value = Child.Value.Split(Separate); }
|
||||
|
||||
public void Reader(XAttribute Entry, ref string[] value, string localName, params char[] Separate)
|
||||
{ if (Entry.Name == localName) value = Entry.Value.Split(Separate); }
|
||||
|
||||
public void Writer(XElement element, bool value, string localName) =>
|
||||
Writer(element, value.ToString().ToLower(), localName);
|
||||
|
||||
public void Writer(XElement element, long value, string localName) =>
|
||||
Writer(element, value.ToString().ToLower(), localName);
|
||||
|
||||
public void Writer(XElement element, ulong value, string localName) =>
|
||||
Writer(element, value.ToString().ToLower(), localName);
|
||||
|
||||
public void Writer(XElement element, double value, string localName) =>
|
||||
Writer(element, value.ToString(), localName);
|
||||
|
||||
public void Writer(XElement element, string value, string localName)
|
||||
{
|
||||
if (Compact && value != "" && value != null)
|
||||
element.Add(new XAttribute(localName, value));
|
||||
else if (!Compact)
|
||||
element.Add(new XElement(localName, value));
|
||||
}
|
||||
}
|
||||
}
|
||||
+88
-104
@@ -1,4 +1,4 @@
|
||||
using KKdMainLib;
|
||||
using KKdBaseLib;
|
||||
using KKdMainLib.IO;
|
||||
|
||||
namespace KKdSoundLib
|
||||
@@ -6,124 +6,108 @@ namespace KKdSoundLib
|
||||
public unsafe class DIVA
|
||||
{
|
||||
public DIVAFile Data = new DIVAFile();
|
||||
|
||||
public string file = "";
|
||||
private int c, i;
|
||||
|
||||
public DIVA() { Data = new DIVAFile(); file = ""; }
|
||||
public DIVA(string filepath) { Data = new DIVAFile(); file = filepath; }
|
||||
public DIVA() { Data = new DIVAFile(); }
|
||||
|
||||
public void DIVAReader(bool ToArray = false)
|
||||
public void DIVAReader(string file, bool ToArray = false)
|
||||
{
|
||||
if (File.Exists(file + ".diva"))
|
||||
{
|
||||
Data = new DIVAFile();
|
||||
Stream reader = File.OpenReader(file + ".diva");
|
||||
if (!File.Exists(file + ".diva")) return;
|
||||
|
||||
if (reader.ReadString(0x04) == "DIVA")
|
||||
{
|
||||
reader.ReadInt32();
|
||||
Data.Size = reader.ReadUInt32();
|
||||
Data.SampleRate = reader.ReadUInt32();
|
||||
Data.SamplesCount = reader.ReadUInt32();
|
||||
reader.ReadInt64();
|
||||
Data.Channels = reader.ReadUInt16();
|
||||
reader.ReadUInt16();
|
||||
Data.Name = reader.ReadString(0x20);
|
||||
Data = new DIVAFile();
|
||||
Stream reader = File.OpenReader(file + ".diva");
|
||||
|
||||
Stream writer = File.OpenWriter();
|
||||
if (!ToArray) writer = File.OpenWriter(file + ".wav", true);
|
||||
writer.LongPosition = 0x2C;
|
||||
if (reader.ReadString(0x04) != "DIVA") { reader.Close(); return; }
|
||||
|
||||
byte value = 0;
|
||||
int[] current = new int[Data.Channels];
|
||||
int[] currentclamp = new int[Data.Channels];
|
||||
sbyte[] stepindex = new sbyte[Data.Channels];
|
||||
float f;
|
||||
reader.ReadInt32();
|
||||
Data.Size = reader.ReadUInt32();
|
||||
Data.SampleRate = reader.ReadUInt32();
|
||||
Data.SamplesCount = reader.ReadUInt32();
|
||||
reader.ReadInt64();
|
||||
Data.Channels = reader.ReadUInt16();
|
||||
reader.ReadUInt16();
|
||||
Data.Name = reader.ReadString(0x20);
|
||||
|
||||
int* currentPtr = current.GetPtr();
|
||||
int* currentclampPtr = currentclamp.GetPtr();
|
||||
sbyte* stepindexPtr = stepindex.GetPtr();
|
||||
|
||||
for (i = 0; i < Data.SamplesCount; i++)
|
||||
for (c = 0; c < Data.Channels; c++)
|
||||
{
|
||||
value = reader.ReadHalfByte();
|
||||
IMADecoder(value, ref currentPtr[c], ref currentclampPtr[c], ref stepindexPtr[c]);
|
||||
f = (float)(currentPtr[c] / 32768.0);
|
||||
writer.Write(f);
|
||||
}
|
||||
|
||||
WAV.Header Header = new WAV.Header
|
||||
{ Bytes = 4, Channels = Data.Channels, Format = 3,
|
||||
SampleRate = Data.SampleRate, Size = Data.SamplesCount * Data.Channels * 4};
|
||||
writer.Write(Header, 0);
|
||||
if (ToArray) Data.Data = writer.ToArray();
|
||||
writer.Close();
|
||||
}
|
||||
reader.Close();
|
||||
}
|
||||
}
|
||||
|
||||
private byte[] BuildWavHeader(WAV.Header Header, short Bytes)
|
||||
{
|
||||
Stream writer = File.OpenWriter();
|
||||
writer.Write(Header);
|
||||
byte[] Data = writer.ToArray();
|
||||
if (!ToArray) writer = File.OpenWriter(file + ".wav", true);
|
||||
writer.LongPosition = 0x2C;
|
||||
|
||||
byte value = 0;
|
||||
int[] current = new int[Data.Channels];
|
||||
int[] currentclamp = new int[Data.Channels];
|
||||
sbyte[] stepindex = new sbyte[Data.Channels];
|
||||
float f;
|
||||
|
||||
int* currentPtr = current.GetPtr();
|
||||
int* currentclampPtr = currentclamp.GetPtr();
|
||||
sbyte* stepindexPtr = stepindex.GetPtr();
|
||||
|
||||
for (i = 0; i < Data.SamplesCount; i++)
|
||||
for (c = 0; c < Data.Channels; c++)
|
||||
{
|
||||
value = reader.ReadHalfByte();
|
||||
IMADecoder(value, ref currentPtr[c], ref currentclampPtr[c], ref stepindexPtr[c]);
|
||||
f = (float)(currentPtr[c] / 32768.0);
|
||||
writer.Write(f);
|
||||
}
|
||||
|
||||
WAV.Header Header = new WAV.Header { Bytes = 4, Channels = Data.Channels, Format = 3,
|
||||
SampleRate = Data.SampleRate, Size = Data.SamplesCount * Data.Channels * 4 };
|
||||
writer.Write(Header, 0);
|
||||
if (ToArray) Data.Data = writer.ToArray();
|
||||
writer.Close();
|
||||
return Data;
|
||||
|
||||
reader.Close();
|
||||
}
|
||||
|
||||
public void DIVAWriter()
|
||||
public void DIVAWriter(string file)
|
||||
{
|
||||
if (File.Exists(file + ".wav"))
|
||||
{
|
||||
Stream reader = File.OpenReader(file + ".wav");
|
||||
Stream writer = File.OpenWriter(file + ".diva", true);
|
||||
|
||||
Data = new DIVAFile();
|
||||
WAV.Header Header = reader.ReadWAVHeader();
|
||||
if (Header.IsSupported)
|
||||
if (!File.Exists(file + ".wav")) return;
|
||||
|
||||
Stream reader = File.OpenReader(file + ".wav");
|
||||
|
||||
Data = new DIVAFile();
|
||||
WAV.Header Header = reader.ReadWAVHeader();
|
||||
if (!Header.IsSupported) { reader.Close(); return; }
|
||||
|
||||
Stream writer = File.OpenWriter(file + ".diva", true);
|
||||
Data.Channels = Header.Channels;
|
||||
Data.SampleRate = Header.SampleRate;
|
||||
writer.LongPosition = 0x40;
|
||||
|
||||
byte value = 0;
|
||||
int[] sample = new int[Data.Channels];
|
||||
int[] current = new int[Data.Channels];
|
||||
int[] currentclamp = new int[Data.Channels];
|
||||
sbyte[] stepindex = new sbyte[Data.Channels];
|
||||
|
||||
int* samplePtr = sample.GetPtr();
|
||||
int* currentPtr = current.GetPtr();
|
||||
int* currentclampPtr = currentclamp.GetPtr();
|
||||
sbyte* stepindexPtr = stepindex.GetPtr();
|
||||
Data.SamplesCount = Header.Size / Header.Channels / Header.Bytes;
|
||||
|
||||
for (i = 0; i < Data.SamplesCount; i++)
|
||||
for (c = 0; c < Header.Channels; c++)
|
||||
{
|
||||
Data.Channels = Header.Channels;
|
||||
Data.SampleRate = Header.SampleRate;
|
||||
writer.LongPosition = 0x40;
|
||||
|
||||
byte value = 0;
|
||||
int[] sample = new int[Data.Channels];
|
||||
int[] current = new int[Data.Channels];
|
||||
int[] currentclamp = new int[Data.Channels];
|
||||
sbyte[] stepindex = new sbyte[Data.Channels];
|
||||
|
||||
int* samplePtr = sample.GetPtr();
|
||||
int* currentPtr = current.GetPtr();
|
||||
int* currentclampPtr = currentclamp.GetPtr();
|
||||
sbyte* stepindexPtr = stepindex.GetPtr();
|
||||
Data.SamplesCount = Header.Size / Header.Channels / Header.Bytes;
|
||||
|
||||
for (i = 0; i < Data.SamplesCount; i++)
|
||||
for (c = 0; c < Header.Channels; c++)
|
||||
{
|
||||
samplePtr[c] = (reader.ReadWAVSample(Header.Bytes, Header.Format) * 0x8000).CFTI();
|
||||
value = IMAEncoder(samplePtr[c], ref currentPtr[c],
|
||||
ref currentclampPtr[c], ref stepindexPtr[c]);
|
||||
writer.Write(value, 4);
|
||||
}
|
||||
writer.CheckWrited();
|
||||
|
||||
writer.LongPosition = 0x00;
|
||||
writer.Write("DIVA");
|
||||
writer.Write(0x00);
|
||||
writer.Write((Data.SamplesCount * Data.Channels).Align(2, 2));
|
||||
writer.Write(Data.SampleRate);
|
||||
writer.Write(Data.SamplesCount);
|
||||
writer.Write(0x00);
|
||||
writer.Write(0x00);
|
||||
writer.Write(Data.Channels);
|
||||
samplePtr[c] = (reader.ReadWAVSample(Header.Bytes, Header.Format) * 0x8000).CFTI();
|
||||
value = IMAEncoder(samplePtr[c], ref currentPtr[c],
|
||||
ref currentclampPtr[c], ref stepindexPtr[c]);
|
||||
writer.Write(value, 4);
|
||||
}
|
||||
reader.Close();
|
||||
writer.Close();
|
||||
}
|
||||
writer.CW();
|
||||
|
||||
writer.LongPosition = 0x00;
|
||||
writer.Write("DIVA");
|
||||
writer.Write(0x00);
|
||||
writer.Write((Data.SamplesCount * Data.Channels).Align(2, 2));
|
||||
writer.Write(Data.SampleRate);
|
||||
writer.Write(Data.SamplesCount);
|
||||
writer.Write(0x00);
|
||||
writer.Write(0x00);
|
||||
writer.Write(Data.Channels);
|
||||
writer.Close();
|
||||
reader.Close();
|
||||
}
|
||||
|
||||
private void IMADecoder(byte value, ref int current, ref int currentclamp, ref sbyte stepindex)
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
using KKdMainLib.IO;
|
||||
using KKdBaseLib;
|
||||
using KKdMainLib.IO;
|
||||
|
||||
namespace KKdSoundLib
|
||||
{
|
||||
@@ -15,10 +16,10 @@ namespace KKdSoundLib
|
||||
|
||||
public static void Write(this Stream IO, double Sample, ushort Bytes, ushort Format)
|
||||
{
|
||||
if (Bytes == 2) IO.Write ((ushort)(Sample * 0x00008000));
|
||||
else if (Bytes == 4 && Format == 0x01) IO.Write (( int)(Sample * 0x80000000));
|
||||
else if (Bytes == 4 && Format == 0x03) IO.Write ((float) Sample);
|
||||
else if (Bytes == 8 && Format == 0x03) IO.Write ( Sample);
|
||||
if (Bytes == 2) IO.Write((Sample * 0x00008000).CFTS());
|
||||
else if (Bytes == 4 && Format == 0x01) IO.Write((Sample * 0x80000000).CFTI());
|
||||
else if (Bytes == 4 && Format == 0x03) IO.Write((float)Sample);
|
||||
else if (Bytes == 8 && Format == 0x03) IO.Write( Sample);
|
||||
}
|
||||
|
||||
public static WAV.Header ReadWAVHeader(this Stream IO)
|
||||
@@ -46,7 +47,7 @@ namespace KKdSoundLib
|
||||
Header.Format = IO.ReadUInt16();
|
||||
}
|
||||
if (Header.Bytes < 1 || (Header.Bytes > 4 && Header.Bytes != 8)) return Header;
|
||||
if (Header.Bytes > 0 && Header.Bytes < 4 && Header.Format == 3) return Header;
|
||||
if (Header.Bytes > 0 && Header.Bytes < 4 && Header.Format == 3 ) return Header;
|
||||
if (Header.Bytes == 8 && Header.Format == 1) return Header;
|
||||
IO.Seek(Offset + 0x14, 0);
|
||||
if (IO.ReadString(4) != "data") return Header;
|
||||
|
||||
@@ -22,6 +22,8 @@
|
||||
<ErrorReport>prompt</ErrorReport>
|
||||
<WarningLevel>4</WarningLevel>
|
||||
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
|
||||
<LangVersion>7.3</LangVersion>
|
||||
<NoWarn>IDE0044, IDE0045, IDE0046, IDE0055, IDE0059, IDE1006</NoWarn>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
|
||||
<PlatformTarget>AnyCPU</PlatformTarget>
|
||||
@@ -33,6 +35,8 @@
|
||||
<WarningLevel>4</WarningLevel>
|
||||
<DebugSymbols>true</DebugSymbols>
|
||||
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
|
||||
<LangVersion>7.3</LangVersion>
|
||||
<NoWarn>IDE0044, IDE0045, IDE0046, IDE0055, IDE0059, IDE1006</NoWarn>
|
||||
</PropertyGroup>
|
||||
<ItemGroup>
|
||||
<Compile Include="Extensions.cs" />
|
||||
@@ -46,10 +50,12 @@
|
||||
<Reference Include="System.Drawing" />
|
||||
<Reference Include="System.Numerics" />
|
||||
<Reference Include="System.Windows.Forms" />
|
||||
<Reference Include="System.Xml" />
|
||||
<Reference Include="System.Xml.Linq" />
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ProjectReference Include="..\KKdBaseLib\KKdBaseLib.csproj">
|
||||
<Project>{da55bfd3-927e-473c-a779-f9e6365384ae}</Project>
|
||||
<Name>KKdBaseLib</Name>
|
||||
</ProjectReference>
|
||||
<ProjectReference Include="..\KKdMainLib\KKdMainLib.csproj">
|
||||
<Project>{2BA7EFC6-91D1-8BBC-C487-06C7F36CC789}</Project>
|
||||
<Name>KKdMainLib</Name>
|
||||
|
||||
@@ -2,14 +2,14 @@
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
[assembly: AssemblyTitle("KKdSoundLib")]
|
||||
[assembly: AssemblyDescription("")]
|
||||
[assembly: AssemblyDescription("A simple library for working with Project Diva F/AFT/F2/X/FT audio files")]
|
||||
[assembly: AssemblyConfiguration("")]
|
||||
[assembly: AssemblyCompany("")]
|
||||
[assembly: AssemblyProduct("KKdSoundLib")]
|
||||
[assembly: AssemblyCopyright("Copyright korenkonder © 2019")]
|
||||
[assembly: AssemblyCopyright("korenkonder © 2019")]
|
||||
[assembly: AssemblyTrademark("")]
|
||||
[assembly: AssemblyCulture("")]
|
||||
[assembly: ComVisible(false)]
|
||||
[assembly: Guid("D8A3F2D7-10CC-5723-EC9A-45D3B9C2DFEA")]
|
||||
[assembly: AssemblyVersion("0.0.2.2")]
|
||||
[assembly: AssemblyFileVersion("0.0.2.2")]
|
||||
[assembly: AssemblyVersion("0.0.3.0")]
|
||||
[assembly: AssemblyFileVersion("0.0.3.0")]
|
||||
|
||||
+80
-53
@@ -1,4 +1,4 @@
|
||||
using KKdMainLib;
|
||||
using KKdBaseLib;
|
||||
using KKdMainLib.IO;
|
||||
|
||||
namespace KKdSoundLib
|
||||
@@ -12,19 +12,17 @@ namespace KKdSoundLib
|
||||
private const uint BS = 28; //VAGBlockSize
|
||||
private int[] Samp1, Samp2, Samp3, Samp4;
|
||||
private int* S1Ptr, S2Ptr, S3Ptr, S4Ptr;
|
||||
private bool Success = false;
|
||||
|
||||
public VAGFile VAGData = new VAGFile();
|
||||
public string file = "";
|
||||
|
||||
public VAG() { VAGData = new VAGFile(); file = "";
|
||||
public VAG() { VAGData = new VAGFile();
|
||||
HEVAG1Ptr = HEVAG1.GetPtr(); HEVAG2Ptr = HEVAG2.GetPtr();
|
||||
HEVAG3Ptr = HEVAG3.GetPtr(); HEVAG4Ptr = HEVAG4.GetPtr();
|
||||
}
|
||||
|
||||
public VAG(string filepath) { VAGData = new VAGFile(); file = filepath; }
|
||||
HEVAG3Ptr = HEVAG3.GetPtr(); HEVAG4Ptr = HEVAG4.GetPtr(); }
|
||||
|
||||
public void VAGReader()
|
||||
public void VAGReader(string file)
|
||||
{
|
||||
Success = false;
|
||||
if (!File.Exists(file + ".vag")) return;
|
||||
|
||||
VAGData = new VAGFile();
|
||||
@@ -91,7 +89,6 @@ namespace KKdSoundLib
|
||||
VAGData.DataPtr[i * ch + c] = temp_bufferPtr[i ];
|
||||
VAGData.DataPtr[i2 * ch + c] = temp_bufferPtr[i2];
|
||||
}
|
||||
|
||||
}
|
||||
else
|
||||
for (i1 = 0; i1 < VAGData.Size; i1++, VAGData.DataPtr += VBS)
|
||||
@@ -120,8 +117,8 @@ namespace KKdSoundLib
|
||||
d1 = four_bitPtr[i2];
|
||||
if (d0 > 7) d0 -= 16;
|
||||
if (d1 > 7) d1 -= 16;
|
||||
d0 = d0 << (20 - ShF);
|
||||
d1 = d1 << (20 - ShF);
|
||||
d0 <<= (20 - ShF);
|
||||
d1 <<= (20 - ShF);
|
||||
|
||||
g = ((tS1 >> 8) * VAG_1 + (tS2 >> 8) * VAG_2) >> 5;
|
||||
tS2 = tS1; tS1 = g + d0;
|
||||
@@ -146,6 +143,7 @@ namespace KKdSoundLib
|
||||
|
||||
VAGData.DataPtr = VAGData.OriginDataPtr;
|
||||
reader.Close();
|
||||
Success = true;
|
||||
}
|
||||
|
||||
private void DecodeHEVAG()
|
||||
@@ -157,8 +155,8 @@ namespace KKdSoundLib
|
||||
d1 = four_bitPtr[i2];
|
||||
if (d0 > 7) d0 -= 16;
|
||||
if (d1 > 7) d1 -= 16;
|
||||
d0 = d0 << (20 - ShF);
|
||||
d1 = d1 << (20 - ShF);
|
||||
d0 <<= (20 - ShF);
|
||||
d1 <<= (20 - ShF);
|
||||
|
||||
g = ((tS1 >> 8) * HEVAG_1 + (tS2 >> 8) * HEVAG_2 +
|
||||
(tS3 >> 8) * HEVAG_3 + (tS4 >> 8) * HEVAG_4) >> 5;
|
||||
@@ -175,33 +173,44 @@ namespace KKdSoundLib
|
||||
}
|
||||
}
|
||||
|
||||
public void WAVWriterStraight()
|
||||
public void WAVWriterStraight(string file, bool IgnoreEndFlags = false)
|
||||
{
|
||||
if (!Success) return;
|
||||
byte Flag = VAGData.Flags[0];
|
||||
if (Flag == 7) return;
|
||||
WAV.Header Header = new WAV.Header();
|
||||
Stream writer = File.OpenWriter(file + ".wav", true);
|
||||
writer.LongPosition = 0x2C;
|
||||
|
||||
for (i = 0; i < BS; i++)
|
||||
for (c = 0; c < ch; c++)
|
||||
{
|
||||
f = (float)(VAGData.DataPtr[i * ch + c] / 8388608.0);
|
||||
writer.Write(f);
|
||||
}
|
||||
|
||||
for (i1 = 0, i2 = 0; i1 < VAGData.Size; i1++, VAGData.DataPtr += VBS)
|
||||
{
|
||||
Flag = VAGData.Flags[i1];
|
||||
if (Flag == 5 || Flag > 6) break;
|
||||
|
||||
if (Flag < 8)
|
||||
for (i = 0; i < BS; i++)
|
||||
for (c = 0; c < ch; c++)
|
||||
{
|
||||
f = (float)(VAGData.DataPtr[i * ch + c] / 8388608.0);
|
||||
writer.Write(f);
|
||||
}
|
||||
else
|
||||
for (i = 0; i < BS; i++)
|
||||
for (c = 0; c < ch; c++)
|
||||
writer.Write(0f);
|
||||
|
||||
if (Flag == 1) break;
|
||||
for (i1 = 0, i2 = 0; i1 < VAGData.Size; i1++, VAGData.DataPtr += VBS)
|
||||
{
|
||||
Flag = VAGData.Flags[i1];
|
||||
if (!IgnoreEndFlags && Flag == 5 || Flag == 7) break;
|
||||
if (Flag < 8)
|
||||
for (i = 0; i < BS; i++)
|
||||
for (c = 0; c < ch; c++)
|
||||
{
|
||||
f = (float)(VAGData.DataPtr[i * ch + c] / 8388608.0);
|
||||
writer.Write(f);
|
||||
}
|
||||
else
|
||||
for (i = 0; i < BS; i++)
|
||||
for (c = 0; c < ch; c++)
|
||||
writer.Write(0f);
|
||||
|
||||
if (!IgnoreEndFlags && Flag == 1) break;
|
||||
}
|
||||
VAGData.DataPtr = VAGData.OriginDataPtr;
|
||||
|
||||
@@ -211,29 +220,36 @@ namespace KKdSoundLib
|
||||
writer.Close();
|
||||
}
|
||||
|
||||
public void WAVWriter()
|
||||
public void WAVWriter(string file, bool IgnoreEndFlags = false)
|
||||
{
|
||||
if (!Success) return;
|
||||
byte Flag = VAGData.Flags[0];
|
||||
if (Flag == 7) return;
|
||||
WAV.Header Header = new WAV.Header();
|
||||
Stream writer;
|
||||
if (Flag == 6) writer = File.OpenWriter(file + ".loop.0.wav", true);
|
||||
else writer = File.OpenWriter(file + ".0.wav", true);
|
||||
if (!IgnoreEndFlags && Flag == 6) writer = File.OpenWriter(file + ".loop.0.wav", true);
|
||||
else writer = File.OpenWriter(file + ".0.wav", true);
|
||||
writer.LongPosition = 0x2C;
|
||||
|
||||
for (i = 0; i < BS; i++)
|
||||
for (c = 0; c < ch; c++)
|
||||
{
|
||||
f = (float)(VAGData.DataPtr[i * ch + c] / 8388608.0);
|
||||
writer.Write(f);
|
||||
}
|
||||
if (Flag < 8)
|
||||
for (i = 0; i < BS; i++)
|
||||
for (c = 0; c < ch; c++)
|
||||
{
|
||||
f = (float)(VAGData.DataPtr[i * ch + c] / 8388608.0);
|
||||
writer.Write(f);
|
||||
}
|
||||
else
|
||||
for (i = 0; i < BS; i++)
|
||||
for (c = 0; c < ch; c++)
|
||||
writer.Write(0f);
|
||||
|
||||
VAGData.DataPtr += VBS;
|
||||
|
||||
for (i1 = 1, i2 = 0; i1 < VAGData.Size; i1++, VAGData.DataPtr += VBS)
|
||||
{
|
||||
Flag = VAGData.Flags[i1];
|
||||
if (Flag == 5 || Flag > 6) break;
|
||||
else if (Flag == 6)
|
||||
if (!IgnoreEndFlags && Flag == 5 || Flag == 7) break;
|
||||
else if (!IgnoreEndFlags && Flag == 6)
|
||||
{
|
||||
Header = new WAV.Header { Bytes = 4, Channels = ch, Format = 3, SampleRate =
|
||||
VAGData.SampleRate, Size = writer.UIntPosition - 0x2C };
|
||||
@@ -245,15 +261,20 @@ namespace KKdSoundLib
|
||||
writer.LongPosition = 0x2C;
|
||||
}
|
||||
|
||||
for (i = 0; i < BS; i++)
|
||||
for (c = 0; c < ch; c++)
|
||||
{
|
||||
f = (float)(VAGData.DataPtr[i * ch + c] / 8388608.0);
|
||||
writer.Write(f);
|
||||
}
|
||||
if (!IgnoreEndFlags && Flag < 8)
|
||||
for (i = 0; i < BS; i++)
|
||||
for (c = 0; c < ch; c++)
|
||||
{
|
||||
f = (float)(VAGData.DataPtr[i * ch + c] / 8388608.0);
|
||||
writer.Write(f);
|
||||
}
|
||||
else
|
||||
for (i = 0; i < BS; i++)
|
||||
for (c = 0; c < ch; c++)
|
||||
writer.Write(0f);
|
||||
|
||||
if (Flag == 1) break;
|
||||
else if (Flag == 3)
|
||||
if (!IgnoreEndFlags && Flag == 1) break;
|
||||
else if (!IgnoreEndFlags && Flag == 3)
|
||||
{
|
||||
Header = new WAV.Header { Bytes = 4, Channels = ch, Format = 3, SampleRate =
|
||||
VAGData.SampleRate, Size = writer.UIntPosition - 0x2C };
|
||||
@@ -276,8 +297,9 @@ namespace KKdSoundLib
|
||||
writer.Close();
|
||||
}
|
||||
|
||||
public int WAVReaderStraight(bool ExtendedFlagging = false)
|
||||
public int WAVReaderStraight(string file, bool ExtendedFlagging = false)
|
||||
{
|
||||
Success = false;
|
||||
VAGData = new VAGFile();
|
||||
Stream reader = File.OpenReader(file + ".wav");
|
||||
WAV.Header Header = reader.ReadWAVHeader();
|
||||
@@ -318,16 +340,18 @@ namespace KKdSoundLib
|
||||
VAGData.Flags[VAGData.Size - 1] = 0x1;
|
||||
|
||||
reader.Close();
|
||||
Success = true;
|
||||
return 0;
|
||||
}
|
||||
|
||||
public int WAVReader(bool ExtendedFlagging = false)
|
||||
public int WAVReader(string file, bool ExtendedFlagging = false)
|
||||
{
|
||||
Success = false;
|
||||
string[] Files;
|
||||
bool HasLoop = false;
|
||||
bool[] Loop;
|
||||
{
|
||||
if (!file.EndsWith(".0")) return WAVReaderStraight();
|
||||
if (!file.EndsWith(".0")) return WAVReaderStraight(file);
|
||||
file = file.Remove(file.Length - 2);
|
||||
i2 = 0;
|
||||
System.Collections.Generic.List<string> files =
|
||||
@@ -430,11 +454,13 @@ namespace KKdSoundLib
|
||||
VAGData.Channels = ch;
|
||||
VAGData.SampleRate = SampleRate;
|
||||
|
||||
Success = true;
|
||||
return 0;
|
||||
}
|
||||
|
||||
public void VAGWriter(bool HEVAG = true)
|
||||
public void VAGWriter(string file, bool HEVAG = true)
|
||||
{
|
||||
if (!Success) return;
|
||||
VAGData.Name = Path.GetFileName(file);
|
||||
Stream writer = File.OpenWriter(file + ".vag", true);
|
||||
Samp1 = new int[ch]; S1Ptr = Samp1.GetPtr();
|
||||
@@ -465,6 +491,7 @@ namespace KKdSoundLib
|
||||
if (HEVAG) writer.Write(VAGData.Channels);
|
||||
else writer.Write((ushort)0x1);
|
||||
writer.Write(VAGData.Name);
|
||||
writer.LongLength = 0x30;
|
||||
writer.LongPosition = 0x30;
|
||||
|
||||
if (HEVAG)
|
||||
@@ -585,7 +612,7 @@ namespace KKdSoundLib
|
||||
|
||||
ShF = 0;
|
||||
ShM = 0x4000;
|
||||
min = min >> 8;
|
||||
min >>= 8;
|
||||
|
||||
while (ShF < 12)
|
||||
{
|
||||
@@ -608,7 +635,7 @@ namespace KKdSoundLib
|
||||
if (d0 > 7) d0 = 7;
|
||||
if (d0 < -8) d0 = -8;
|
||||
four_bitPtr[i] = d0 & 0xF;
|
||||
d0 = d0 << (20 - ShF);
|
||||
d0 <<= (20 - ShF);
|
||||
|
||||
S2 = S1; S1 = d0 - e;
|
||||
}
|
||||
@@ -686,7 +713,7 @@ namespace KKdSoundLib
|
||||
if (d0 > 7) d0 = 7;
|
||||
if (d0 < -8) d0 = -8;
|
||||
four_bitPtr[i] = d0 & 0xF;
|
||||
d0 = d0 << (20 - ShF);
|
||||
d0 <<= (20 - ShF);
|
||||
|
||||
tS4 = tS3; tS3 = tS2; tS2 = tS1; tS1 = d0 - e;
|
||||
i++;
|
||||
|
||||
+1
-7
@@ -1,10 +1,4 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace KKdSoundLib
|
||||
namespace KKdSoundLib
|
||||
{
|
||||
public static class WAV
|
||||
{
|
||||
|
||||
+13
-7
@@ -1,24 +1,26 @@
|
||||
|
||||
Microsoft Visual Studio Solution File, Format Version 12.00
|
||||
# Visual Studio 15
|
||||
VisualStudioVersion = 15.0.27130.2003
|
||||
# Visual Studio Version 16
|
||||
VisualStudioVersion = 16.0.29025.244
|
||||
MinimumVisualStudioVersion = 10.0.40219.1
|
||||
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PD_Tool", "PD_Tool\PD_Tool.csproj", "{7B5D5A3A-A6F8-4813-C97D-ACFC98F7397E}"
|
||||
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "KKdBaseLib", "KKdBaseLib\KKdBaseLib.csproj", "{437F63F1-8C23-429E-AB14-38B85C9EDB16}"
|
||||
EndProject
|
||||
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "KKdMainLib", "KKdMainLib\KKdMainLib.csproj", "{2BA7EFC6-91D1-8BBC-C487-06C7F36CC789}"
|
||||
EndProject
|
||||
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "KKdSoundLib", "KKdSoundLib\KKdSoundLib.csproj", "{D8A3F2D7-10CC-5723-EC9A-45D3B9C2DFEA}"
|
||||
EndProject
|
||||
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PD_Tool", "PD_Tool\PD_Tool.csproj", "{7B5D5A3A-A6F8-4813-C97D-ACFC98F7397E}"
|
||||
EndProject
|
||||
Global
|
||||
GlobalSection(SolutionConfigurationPlatforms) = preSolution
|
||||
Debug|Any CPU = Debug|Any CPU
|
||||
Release|Any CPU = Release|Any CPU
|
||||
EndGlobalSection
|
||||
GlobalSection(ProjectConfigurationPlatforms) = postSolution
|
||||
{7B5D5A3A-A6F8-4813-C97D-ACFC98F7397E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
|
||||
{7B5D5A3A-A6F8-4813-C97D-ACFC98F7397E}.Debug|Any CPU.Build.0 = Debug|Any CPU
|
||||
{7B5D5A3A-A6F8-4813-C97D-ACFC98F7397E}.Release|Any CPU.ActiveCfg = Release|Any CPU
|
||||
{7B5D5A3A-A6F8-4813-C97D-ACFC98F7397E}.Release|Any CPU.Build.0 = Release|Any CPU
|
||||
{437F63F1-8C23-429E-AB14-38B85C9EDB16}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
|
||||
{437F63F1-8C23-429E-AB14-38B85C9EDB16}.Debug|Any CPU.Build.0 = Debug|Any CPU
|
||||
{437F63F1-8C23-429E-AB14-38B85C9EDB16}.Release|Any CPU.ActiveCfg = Release|Any CPU
|
||||
{437F63F1-8C23-429E-AB14-38B85C9EDB16}.Release|Any CPU.Build.0 = Release|Any CPU
|
||||
{2BA7EFC6-91D1-8BBC-C487-06C7F36CC789}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
|
||||
{2BA7EFC6-91D1-8BBC-C487-06C7F36CC789}.Debug|Any CPU.Build.0 = Debug|Any CPU
|
||||
{2BA7EFC6-91D1-8BBC-C487-06C7F36CC789}.Release|Any CPU.ActiveCfg = Release|Any CPU
|
||||
@@ -27,6 +29,10 @@ Global
|
||||
{D8A3F2D7-10CC-5723-EC9A-45D3B9C2DFEA}.Debug|Any CPU.Build.0 = Debug|Any CPU
|
||||
{D8A3F2D7-10CC-5723-EC9A-45D3B9C2DFEA}.Release|Any CPU.ActiveCfg = Release|Any CPU
|
||||
{D8A3F2D7-10CC-5723-EC9A-45D3B9C2DFEA}.Release|Any CPU.Build.0 = Release|Any CPU
|
||||
{7B5D5A3A-A6F8-4813-C97D-ACFC98F7397E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
|
||||
{7B5D5A3A-A6F8-4813-C97D-ACFC98F7397E}.Debug|Any CPU.Build.0 = Debug|Any CPU
|
||||
{7B5D5A3A-A6F8-4813-C97D-ACFC98F7397E}.Release|Any CPU.ActiveCfg = Release|Any CPU
|
||||
{7B5D5A3A-A6F8-4813-C97D-ACFC98F7397E}.Release|Any CPU.Build.0 = Release|Any CPU
|
||||
EndGlobalSection
|
||||
GlobalSection(SolutionProperties) = preSolution
|
||||
HideSolutionNode = FALSE
|
||||
|
||||
+15
-3
@@ -22,6 +22,8 @@
|
||||
<ErrorReport>prompt</ErrorReport>
|
||||
<WarningLevel>4</WarningLevel>
|
||||
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
|
||||
<LangVersion>7.3</LangVersion>
|
||||
<NoWarn>IDE0044, IDE0045, IDE0046, IDE0055, IDE0059, IDE1006</NoWarn>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
|
||||
<PlatformTarget>AnyCPU</PlatformTarget>
|
||||
@@ -33,15 +35,23 @@
|
||||
<WarningLevel>4</WarningLevel>
|
||||
<DebugSymbols>true</DebugSymbols>
|
||||
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
|
||||
<LangVersion>7.3</LangVersion>
|
||||
<NoWarn>IDE0044, IDE0045, IDE0046, IDE0055, IDE0059, IDE1006</NoWarn>
|
||||
</PropertyGroup>
|
||||
<ItemGroup>
|
||||
<Compile Include="classes\DataBase.cs" />
|
||||
<Compile Include="classes\Tools\A3D.cs" />
|
||||
<Compile Include="classes\Tools\AET.cs" />
|
||||
<Compile Include="classes\Tools\BLT.cs" />
|
||||
<Compile Include="classes\Tools\CCT.cs" />
|
||||
<Compile Include="classes\Tools\DB.cs" />
|
||||
<Compile Include="classes\Tools\DEX.cs" />
|
||||
<Compile Include="classes\Tools\DFT.cs" />
|
||||
<Compile Include="classes\Tools\DIV.cs" />
|
||||
<Compile Include="classes\Tools\LIT.cs" />
|
||||
<Compile Include="classes\Tools\MOT.cs" />
|
||||
<Compile Include="classes\Tools\STR.cs" />
|
||||
<Compile Include="classes\Tools\VAG.cs" />
|
||||
<Compile Include="classes\DataBase.cs" />
|
||||
<Compile Include="classes\DIVAFILE.cs" />
|
||||
<Compile Include="classes\FARC.cs" />
|
||||
<Compile Include="Program.cs" />
|
||||
@@ -52,10 +62,12 @@
|
||||
<Reference Include="System.Drawing" />
|
||||
<Reference Include="System.Numerics" />
|
||||
<Reference Include="System.Windows.Forms" />
|
||||
<Reference Include="System.Xml" />
|
||||
<Reference Include="System.Xml.Linq" />
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ProjectReference Include="..\KKdBaseLib\KKdBaseLib.csproj">
|
||||
<Project>{437f63f1-8c23-429e-ab14-38b85c9edb16}</Project>
|
||||
<Name>KKdBaseLib</Name>
|
||||
</ProjectReference>
|
||||
<ProjectReference Include="..\KKdMainLib\KKdMainLib.csproj">
|
||||
<Project>{2BA7EFC6-91D1-8BBC-C487-06C7F36CC789}</Project>
|
||||
<Name>KKdMainLib</Name>
|
||||
|
||||
+193
-56
@@ -1,68 +1,68 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System;
|
||||
using System.Windows.Forms;
|
||||
using KKdMainLib;
|
||||
using KKdMainLib.IO;
|
||||
using KKdMain = KKdMainLib.Main;
|
||||
using KKdFARC = KKdMainLib.FARC;
|
||||
|
||||
namespace PD_Tool
|
||||
{
|
||||
public static class Program
|
||||
{
|
||||
public static string function = "";
|
||||
public static List<string> ProcessedFiles = new List<string>();
|
||||
[System.Runtime.InteropServices.DllImport("user32.dll")]
|
||||
private static extern bool SetProcessDPIAware();
|
||||
|
||||
[ThreadStatic] public static string function = "";
|
||||
|
||||
[STAThread]
|
||||
public static void Main(string[] args)
|
||||
{
|
||||
SetProcessDPIAware();
|
||||
|
||||
Console.Title = "PD_Tool";
|
||||
if (args.Length == 0) { while (function != "Q") MainMenu(); Exit(); }
|
||||
|
||||
if (args.Length == 0)
|
||||
{
|
||||
while (function != "Q") MainMenu();
|
||||
Exit();
|
||||
}
|
||||
|
||||
string header;
|
||||
long header;
|
||||
Stream reader;
|
||||
KKdFARC Farc;
|
||||
|
||||
foreach (string arg in args)
|
||||
{
|
||||
Farc = new KKdFARC();
|
||||
if (Directory.Exists(arg)) Farc.Pack(arg);
|
||||
else if (File.Exists(arg) && Path.GetExtension(arg) == ".farc") Farc.UnPack(arg, true);
|
||||
if (Directory.Exists(arg)) new KKdFARC(arg, true).Pack();
|
||||
else if (File.Exists(arg) && Path.GetExtension(arg) == ".farc") new KKdFARC(arg).UnPack(true);
|
||||
else if (File.Exists(arg))
|
||||
{
|
||||
reader = File.OpenReader(arg);
|
||||
header = reader.ReadString(8);
|
||||
header = reader.ReadInt64();
|
||||
reader.Close();
|
||||
if (header.ToUpper() == "DIVAFILE") DIVAFILE.Decrypt(arg);
|
||||
if (header == 0x454C494641564944) KKdMainLib.DIVAFILE.Decrypt(arg);
|
||||
}
|
||||
}
|
||||
Exit();
|
||||
}
|
||||
|
||||
private static bool JSON = false;
|
||||
|
||||
[ThreadStatic] private static bool JSON = true;
|
||||
|
||||
private static void MainMenu()
|
||||
{
|
||||
Console. InputEncoding = System.Text.Encoding.Unicode;
|
||||
Console.OutputEncoding = System.Text.Encoding.Unicode;
|
||||
Console.Title = "PD_Tool";
|
||||
Console.Clear();
|
||||
|
||||
KKdMain.ConsoleDesign(true);
|
||||
KKdMain.ConsoleDesign(" Choose action:");
|
||||
KKdMain.ConsoleDesign(false);
|
||||
KKdMain.ConsoleDesign("1. Extract FARC Archive");
|
||||
KKdMain.ConsoleDesign("2. Create FARC Archive");
|
||||
KKdMain.ConsoleDesign("3. Decrypt from DIVAFILE");
|
||||
KKdMain.ConsoleDesign("4. Encrypt to DIVAFILE");
|
||||
KKdMain.ConsoleDesign("5. DB_Tools");
|
||||
KKdMain.ConsoleDesign("6. Converting Tools");
|
||||
KKdMain.ConsoleDesign(false);
|
||||
KKdMain.ConsoleDesign(JSON ? "M. MessagePack" : "J. JSON");
|
||||
KKdMain.ConsoleDesign("Q. Quit");
|
||||
KKdMain.ConsoleDesign(false);
|
||||
KKdMain.ConsoleDesign(true);
|
||||
ConsoleDesign(true);
|
||||
ConsoleDesign(" Choose action:");
|
||||
ConsoleDesign(false);
|
||||
ConsoleDesign("1. Extract FARC Archive");
|
||||
ConsoleDesign("2. Create FARC Archive");
|
||||
ConsoleDesign("3. Decrypt from DIVAFILE");
|
||||
ConsoleDesign("4. Encrypt to DIVAFILE");
|
||||
ConsoleDesign("5. DB_Tools");
|
||||
ConsoleDesign("6. AC/DT/F/AFT/FT Converting Tools");
|
||||
ConsoleDesign("7. F/F2/X/FT Converting Tools");
|
||||
ConsoleDesign(JSON ? "8. MsgPack to JSON" : "9. JSON to MsgPack");
|
||||
ConsoleDesign(false);
|
||||
ConsoleDesign(JSON ? "M. MessagePack" : "J. JSON");
|
||||
ConsoleDesign("Q. Quit");
|
||||
ConsoleDesign(false);
|
||||
ConsoleDesign(true);
|
||||
Console.WriteLine();
|
||||
|
||||
function = Console.ReadLine().ToUpper();
|
||||
@@ -75,43 +75,180 @@ namespace PD_Tool
|
||||
private static void Functions()
|
||||
{
|
||||
Console.Clear();
|
||||
if (function == "1" || function == "2") FARC.Processor(function == "1");
|
||||
if (function == "1" || function == "2") FARC.Processor(function == "1");
|
||||
else if (function == "3" || function == "4")
|
||||
{
|
||||
KKdMain.Choose(1, "", out string[] FileNames);
|
||||
Choose(1, "", out string[] FileNames);
|
||||
foreach (string FileName in FileNames) DIVAFILE.Decrypt(FileName);
|
||||
}
|
||||
else if (function == "5") DataBase.Processor(JSON);
|
||||
else if (function == "6")
|
||||
{
|
||||
Console.Clear();
|
||||
Console.Title = "Converter Tools";
|
||||
KKdMain.ConsoleDesign(true);
|
||||
KKdMain.ConsoleDesign(" Choose tool:");
|
||||
KKdMain.ConsoleDesign(false);
|
||||
KKdMain.ConsoleDesign("1. A3DA Converter");
|
||||
KKdMain.ConsoleDesign("2. DEX Converter");
|
||||
KKdMain.ConsoleDesign("3. DIVA Converter");
|
||||
KKdMain.ConsoleDesign("4. STR Converter");
|
||||
KKdMain.ConsoleDesign("5. VAG Converter");
|
||||
KKdMain.ConsoleDesign("6. DataBank Converter");
|
||||
KKdMain.ConsoleDesign(false);
|
||||
KKdMain.ConsoleDesign("R. Return to Main Menu");
|
||||
KKdMain.ConsoleDesign(false);
|
||||
KKdMain.ConsoleDesign(true);
|
||||
Console.Title = "AC/DT/F/AFT/FT Converting Tools";
|
||||
ConsoleDesign(true);
|
||||
ConsoleDesign(" Choose converter:");
|
||||
ConsoleDesign(false);
|
||||
ConsoleDesign("1. A3DA" );
|
||||
ConsoleDesign("2. AET" );
|
||||
ConsoleDesign("3. DataBank");
|
||||
ConsoleDesign("4. DEX" );
|
||||
ConsoleDesign("5. DIVA" );
|
||||
ConsoleDesign("6. MOT" );
|
||||
ConsoleDesign("7. STR" );
|
||||
ConsoleDesign(false);
|
||||
ConsoleDesign("R. Return to Main Menu");
|
||||
ConsoleDesign(false);
|
||||
ConsoleDesign(true);
|
||||
Console.WriteLine();
|
||||
string Function = Console.ReadLine();
|
||||
Console.Clear();
|
||||
if (Function == "1") Tools.A3D.Processor(JSON);
|
||||
else if (Function == "2") Tools.DEX.Processor(JSON);
|
||||
else if (Function == "3") Tools.DIV.Processor();
|
||||
else if (Function == "4") Tools.STR.Processor(JSON);
|
||||
else if (Function == "5") Tools.VAG.Processor();
|
||||
else if (Function == "6") Tools.DB .Processor();
|
||||
else if (Function == "2") Tools.AET.Processor(JSON);
|
||||
else if (Function == "3") Tools.DB .Processor(JSON);
|
||||
else if (Function == "4") Tools.DEX.Processor(JSON);
|
||||
else if (Function == "5") Tools.DIV.Processor();
|
||||
else if (Function == "6") Tools.MOT.Processor(JSON);
|
||||
else if (Function == "7") Tools.STR.Processor(JSON);
|
||||
else function = Function;
|
||||
}
|
||||
else if (function == "7")
|
||||
{
|
||||
Console.Clear();
|
||||
Console.Title = "F/F2/X/FT Converting Tools";
|
||||
ConsoleDesign(true);
|
||||
ConsoleDesign(" Choose converter:");
|
||||
ConsoleDesign(false);
|
||||
ConsoleDesign("1. A3DA" );
|
||||
ConsoleDesign("2. Bloom" );
|
||||
ConsoleDesign("3. Color Correction");
|
||||
ConsoleDesign("4. DEX" );
|
||||
ConsoleDesign("5. DOF" );
|
||||
ConsoleDesign("6. Light" );
|
||||
ConsoleDesign("7. STR" );
|
||||
ConsoleDesign("8. VAG" );
|
||||
ConsoleDesign(false);
|
||||
ConsoleDesign("R. Return to Main Menu");
|
||||
ConsoleDesign(false);
|
||||
ConsoleDesign(true);
|
||||
Console.WriteLine();
|
||||
string Function = Console.ReadLine();
|
||||
Console.Clear();
|
||||
if (Function == "1") Tools.A3D.Processor(JSON);
|
||||
else if (Function == "2") Tools.BLT.Processor();
|
||||
else if (Function == "3") Tools.CCT.Processor();
|
||||
else if (Function == "4") Tools.DEX.Processor(JSON);
|
||||
else if (Function == "5") Tools.DFT.Processor();
|
||||
else if (Function == "6") Tools.LIT.Processor();
|
||||
else if (Function == "7") Tools.STR.Processor(JSON);
|
||||
else if (Function == "8") Tools.VAG.Processor();
|
||||
else function = Function;
|
||||
}
|
||||
else if (function == "8")
|
||||
{
|
||||
Choose(1, JSON ? "mp" : "json", out string[] FileNames);
|
||||
foreach (string file in FileNames)
|
||||
if (JSON)
|
||||
{
|
||||
Console.Title = "MsgPack to JSON: " + Path.GetFileNameWithoutExtension(file);
|
||||
MPExt.ToJSON (file.Replace(Path.GetExtension(file), ""));
|
||||
}
|
||||
else
|
||||
{
|
||||
Console.Title = "JSON to MsgPack: " + Path.GetFileNameWithoutExtension(file);
|
||||
MPExt.ToMsgPack(file.Replace(Path.GetExtension(file), ""));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static void Exit() => Environment.Exit(0);
|
||||
|
||||
public static void ConsoleDesign(string text, params string[] args)
|
||||
{
|
||||
text = string.Format(text, args);
|
||||
string Text = "█ █";
|
||||
Text = Text.Remove(3) + text + Text.Remove(0, text.Length + 3);
|
||||
Console.WriteLine(Text);
|
||||
}
|
||||
|
||||
public static void ConsoleDesign(bool Fill)
|
||||
{
|
||||
if (Fill) Console.WriteLine("████████████████████████████████████████████████████");
|
||||
else Console.WriteLine("█ █");
|
||||
}
|
||||
|
||||
private static string GetArgs(string name, bool And, params string[] ext)
|
||||
{
|
||||
int L = ext.Length;
|
||||
string Out = (And ? "|" : "") + name + " files (";
|
||||
for (int i = 0; i < L; i++) { Out += "*." + ext[i]; if (i + 1 < L) Out += ", "; }
|
||||
Out += ")|";
|
||||
for (int i = 0; i < L; i++) { Out += "*." + ext[i]; if (i + 1 < L) Out += ";" ; }
|
||||
return Out;
|
||||
}
|
||||
|
||||
private static string GetArgs(string name, params string[] ext)
|
||||
{
|
||||
int L = ext.Length;
|
||||
string Out = name + " files (";
|
||||
for (int i = 0; i < L; i++) { Out += "*." + ext[i]; if (i + 1 < L) Out += ", "; }
|
||||
Out += ")|";
|
||||
for (int i = 0; i < L; i++) { Out += "*." + ext[i]; if (i + 1 < L) Out += ";" ; }
|
||||
return Out;
|
||||
}
|
||||
|
||||
public static string Choose(int code, string filetype, out string[] FileNames)
|
||||
{
|
||||
string MsgPack = GetArgs("MessagePack", true, "mp" );
|
||||
string JSON = GetArgs("JSON" , true, "json");
|
||||
string BIN = GetArgs("BIN" , true, "bin" );
|
||||
string WAV = GetArgs("WAV" , true, "wav" );
|
||||
|
||||
FileNames = new string[0];
|
||||
if (code == 1)
|
||||
{
|
||||
string Filter = GetArgs("All;", false, "*");
|
||||
if (filetype == "a3da") Filter = GetArgs("A3DA", "a3da", "farc", "json", "mp") +
|
||||
GetArgs("A3DA", true, "a3da") + GetArgs("FARC", true, "farc") + JSON + MsgPack;
|
||||
else if (filetype == "bin" ) Filter = GetArgs("BIN" , "bin", "json", "mp") +
|
||||
BIN + JSON + MsgPack;
|
||||
else if (filetype == "blt" ) Filter = GetArgs("BLT" , "blt");
|
||||
else if (filetype == "bon" ) Filter = GetArgs("BON" , "bon", "bin", "json", "mp") +
|
||||
GetArgs("BON", true, "bon") + BIN + JSON + MsgPack;
|
||||
else if (filetype == "cct" ) Filter = GetArgs("CCT" , "cct");
|
||||
else if (filetype == "databank") Filter = GetArgs("DAT", "dat", "json", "mp") +
|
||||
GetArgs("DAT", true, "dat") + JSON + MsgPack;
|
||||
else if (filetype == "dex" ) Filter = GetArgs("DEX" , "dex", "bin", "json", "mp") +
|
||||
GetArgs("DEX", true, "dex") + BIN + JSON + MsgPack;
|
||||
else if (filetype == "dft" ) Filter = GetArgs("DFT" , "dft");
|
||||
else if (filetype == "diva") Filter = GetArgs("DIVA", "diva", "wav") +
|
||||
GetArgs("DIVA", true, "diva") + GetArgs("WAV", true, "wav");
|
||||
else if (filetype == "dsc" ) Filter = GetArgs("DSC" , "dsc", "json", "mp") +
|
||||
GetArgs("DSC", true, "dsc") + JSON + MsgPack;
|
||||
else if (filetype == "dve" ) Filter = GetArgs("Particles", "farc");
|
||||
else if (filetype == "farc") Filter = "FARC Archives (*.farc)|*.farc";
|
||||
else if (filetype == "json") Filter = GetArgs("JSON", "json");
|
||||
else if (filetype == "mp" ) Filter = GetArgs("MessagePack", "mp");
|
||||
else if (filetype == "lit") Filter = GetArgs("LIT" , "lit");
|
||||
else if (filetype == "str" ) Filter = GetArgs("STR" , "str", "bin", "json", "mp") +
|
||||
GetArgs("STR", true, "str") + BIN + JSON + MsgPack;
|
||||
else if (filetype == "vag" ) Filter = GetArgs("VAG" , "vag", "wav") +
|
||||
GetArgs("VAG", true, "vag") + GetArgs("WAV", true, "wav");
|
||||
|
||||
using (OpenFileDialog ofd = new OpenFileDialog { InitialDirectory = Application.StartupPath,
|
||||
Filter = Filter, Multiselect = true, Title = "Choose file(s) to open:" })
|
||||
if (ofd.ShowDialog() == DialogResult.OK) FileNames = ofd.FileNames;
|
||||
}
|
||||
else if (code == 2)
|
||||
{
|
||||
string Return = "";
|
||||
using (OpenFileDialog ofd = new OpenFileDialog { InitialDirectory = Application.StartupPath,
|
||||
ValidateNames = false, CheckFileExists = false, Filter = " | ", CheckPathExists = true,
|
||||
Title = "Choose any file in folder:", FileName = "Folder Selection." })
|
||||
if (ofd.ShowDialog() == DialogResult.OK) Return = Path.GetDirectoryName(ofd.FileName);
|
||||
return Return;
|
||||
}
|
||||
return "";
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -2,14 +2,14 @@
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
[assembly: AssemblyTitle("PD_Tool")]
|
||||
[assembly: AssemblyDescription("A simple tool for working with Project Diva A/DT/F/AFT/F2/X/FT files")]
|
||||
[assembly: AssemblyDescription("A simple tool for working with Project Diva AC/DT/F/AFT/F2/X/FT files")]
|
||||
[assembly: AssemblyConfiguration("")]
|
||||
[assembly: AssemblyCompany("")]
|
||||
[assembly: AssemblyProduct("PD_Tool")]
|
||||
[assembly: AssemblyCopyright("Copyright korenkonder © 2017-2019")]
|
||||
[assembly: AssemblyCopyright("korenkonder © 2017-2019")]
|
||||
[assembly: AssemblyTrademark("")]
|
||||
[assembly: AssemblyCulture("")]
|
||||
[assembly: ComVisible(false)]
|
||||
[assembly: Guid("7B5D5A3A-A6F8-4813-C97D-ACFC98F7397E")]
|
||||
[assembly: AssemblyVersion("0.4.5.9")]
|
||||
[assembly: AssemblyFileVersion("0.4.5.9")]
|
||||
[assembly: AssemblyVersion("0.4.7.4")]
|
||||
[assembly: AssemblyFileVersion("0.4.7.4")]
|
||||
|
||||
@@ -8,26 +8,20 @@ namespace PD_Tool
|
||||
public static void Decrypt(string file)
|
||||
{
|
||||
Stream reader = File.OpenReader(file);
|
||||
if (reader.ReadInt64() != 0x454C494641564944)
|
||||
{
|
||||
reader.Close();
|
||||
Encrypt(file);
|
||||
return;
|
||||
}
|
||||
if (reader.ReadInt64() != 0x454C494641564944) { reader.Close(); return; }
|
||||
reader.Close();
|
||||
|
||||
System.Console.Title = "DIVAFILE Decrypt: " + Path.GetFileName(file);
|
||||
file.Decrypt();
|
||||
}
|
||||
|
||||
public static void Encrypt(string file)
|
||||
{
|
||||
Stream reader = File.OpenReader(file);
|
||||
if (reader.ReadInt64() == 0x454C494641564944)
|
||||
{
|
||||
reader.Close();
|
||||
Decrypt(file);
|
||||
return;
|
||||
}
|
||||
if (reader.ReadInt64() == 0x454C494641564944) { reader.Close(); return; }
|
||||
reader.Close();
|
||||
|
||||
System.Console.Title = "DIVAFILE Encrypt: " + Path.GetFileName(file);
|
||||
file.Encrypt();
|
||||
}
|
||||
}
|
||||
|
||||
+16
-14
@@ -1,6 +1,5 @@
|
||||
using System;
|
||||
using System.IO;
|
||||
using KKdMainLib;
|
||||
using DB = KKdMainLib.DB;
|
||||
|
||||
namespace PD_Tool
|
||||
@@ -11,16 +10,16 @@ namespace PD_Tool
|
||||
{
|
||||
Console.Title = "DB Converter";
|
||||
Console.Clear();
|
||||
Main.ConsoleDesign(true);
|
||||
Main.ConsoleDesign(" Choose type of DataBase file:");
|
||||
Main.ConsoleDesign(false);
|
||||
Main.ConsoleDesign("1. Auth DB Converter");
|
||||
Main.ConsoleDesign("2. AET DB Converter");
|
||||
Main.ConsoleDesign("3. SPR DB Converter");
|
||||
Main.ConsoleDesign(false);
|
||||
Main.ConsoleDesign("R. Return to Main Menu");
|
||||
Main.ConsoleDesign(false);
|
||||
Main.ConsoleDesign(true);
|
||||
Program.ConsoleDesign(true);
|
||||
Program.ConsoleDesign(" Choose type of DataBase file:");
|
||||
Program.ConsoleDesign(false);
|
||||
Program.ConsoleDesign("1. Auth DB Converter");
|
||||
Program.ConsoleDesign("2. AET DB Converter");
|
||||
Program.ConsoleDesign("3. SPR DB Converter");
|
||||
Program.ConsoleDesign(false);
|
||||
Program.ConsoleDesign("R. Return to Main Menu");
|
||||
Program.ConsoleDesign(false);
|
||||
Program.ConsoleDesign(true);
|
||||
Console.WriteLine();
|
||||
string format = Console.ReadLine();
|
||||
if (format == "1") AuthDBProcessor(JSON);
|
||||
@@ -32,7 +31,7 @@ namespace PD_Tool
|
||||
{
|
||||
Console.Title = "Auth DB Converter";
|
||||
DB.Auth Auth;
|
||||
Main.Choose(1, "bin", out string[] FileNames);
|
||||
Program.Choose(1, "bin", out string[] FileNames);
|
||||
if (FileNames.Length < 1) return;
|
||||
string filepath = "";
|
||||
string ext = "";
|
||||
@@ -54,6 +53,7 @@ namespace PD_Tool
|
||||
Auth.MsgPackReader(filepath, ext == ".json");
|
||||
Auth.BINWriter (filepath);
|
||||
}
|
||||
Auth = null;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -61,7 +61,7 @@ namespace PD_Tool
|
||||
{
|
||||
Console.Title = "AET DB Converter";
|
||||
DB.Aet Aet;
|
||||
Main.Choose(1, "bin", out string[] FileNames);
|
||||
Program.Choose(1, "bin", out string[] FileNames);
|
||||
if (FileNames.Length < 1) return;
|
||||
string filepath = "";
|
||||
string ext = "";
|
||||
@@ -83,6 +83,7 @@ namespace PD_Tool
|
||||
Aet.MsgPackReader(filepath, ext == ".json");
|
||||
Aet.BINWriter (filepath);
|
||||
}
|
||||
Aet = null;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -90,7 +91,7 @@ namespace PD_Tool
|
||||
{
|
||||
Console.Title = "SPR DB Converter";
|
||||
DB.Spr Spr;
|
||||
Main.Choose(1, "bin", out string[] FileNames);
|
||||
Program.Choose(1, "bin", out string[] FileNames);
|
||||
if (FileNames.Length < 1) return;
|
||||
string filepath = "";
|
||||
string ext = "";
|
||||
@@ -112,6 +113,7 @@ namespace PD_Tool
|
||||
Spr.MsgPackReader(filepath, ext == ".json");
|
||||
Spr.BINWriter (filepath);
|
||||
}
|
||||
Spr = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+44
-23
@@ -14,39 +14,60 @@ namespace PD_Tool
|
||||
if (Extract)
|
||||
{
|
||||
Console.Title = "FARC Extractor";
|
||||
Main.Choose(1, "farc", out string[] FileNames);
|
||||
foreach (string FileName in FileNames)
|
||||
if (FileName != "" && File.Exists(FileName))
|
||||
FARC.UnPack(FileName);
|
||||
Program.Choose(1, "farc", out string[] FileNames);
|
||||
foreach (string file in FileNames)
|
||||
if (file != "" && File.Exists(file))
|
||||
{
|
||||
Console.Title = "FARC Extractor: " + Path.GetFileNameWithoutExtension(file);
|
||||
new KKdFARC(file).UnPack();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
string file = Main.Choose(2, "", out string[] FileNames);
|
||||
string file = Program.Choose(2, "", out string[] FileNames);
|
||||
Console.Clear();
|
||||
Console.Title = "FARC Creator";
|
||||
if (file != "")
|
||||
{
|
||||
Main.ConsoleDesign(true);
|
||||
Main.ConsoleDesign(" Choose type of created FARC:");
|
||||
Main.ConsoleDesign(false);
|
||||
Main.ConsoleDesign("1. FArc [DT/DT2nd/DTex/F/F2nd/X]");
|
||||
Main.ConsoleDesign("2. FArC [DT/DT2nd/DTex/F/F2nd/X] (Compressed)");
|
||||
Main.ConsoleDesign("3. FARC [F/F2nd/X] (Compressed)");
|
||||
Main.ConsoleDesign("4. FARC [FT] (Compressed)");
|
||||
Main.ConsoleDesign(false);
|
||||
Main.ConsoleDesign("Note: Creating FT FARCs currently not supported.");
|
||||
Main.ConsoleDesign(false);
|
||||
Main.ConsoleDesign(true);
|
||||
Console.Title = "FARC Creator: " + Path.GetDirectoryName(file);
|
||||
FARC = new KKdFARC();
|
||||
Program.ConsoleDesign(true);
|
||||
Program.ConsoleDesign(" Choose type of created FARC:");
|
||||
Program.ConsoleDesign(false);
|
||||
Program.ConsoleDesign("1. FArc [DT/DT2/DTex/F/F2/X]");
|
||||
Program.ConsoleDesign("2. FArC [DT/DT2/DTex/F/F2/X] (Compressed)");
|
||||
Program.ConsoleDesign("3. FARC [F/F2/X]");
|
||||
Program.ConsoleDesign(false);
|
||||
Program.ConsoleDesign("R. Return to Main Menu");
|
||||
Program.ConsoleDesign(false);
|
||||
Program.ConsoleDesign(true);
|
||||
Console.WriteLine();
|
||||
Console.WriteLine("Choosed folder: {0}", file);
|
||||
Console.WriteLine();
|
||||
int.TryParse(Console.ReadLine(), out int type);
|
||||
if (type == 1) FARC.Signature = KKdFARC.Farc.FArc;
|
||||
else if (type == 3) FARC.Signature = KKdFARC.Farc.FARC;
|
||||
else FARC.Signature = KKdFARC.Farc.FArC;
|
||||
Console.Clear();
|
||||
Console.Title = "FARC Creator - Directory: " + Path.GetDirectoryName(file);
|
||||
FARC.Pack(file);
|
||||
string type = Console.ReadLine().ToUpper();
|
||||
if (type == "1") FARC.Signature = KKdFARC.Farc.FArc;
|
||||
else if (type == "3" || type == "4")
|
||||
{
|
||||
FARC.Signature = KKdFARC.Farc.FARC;
|
||||
|
||||
Console.WriteLine();
|
||||
Program.ConsoleDesign(true);
|
||||
Program.ConsoleDesign(" Choose type of FARC:");
|
||||
Program.ConsoleDesign(false);
|
||||
Program.ConsoleDesign("1. FARC");
|
||||
Program.ConsoleDesign("2. FARC (Compressed)");
|
||||
Program.ConsoleDesign("3. FARC (Encrypted)");
|
||||
Program.ConsoleDesign("4. FARC (Compressed & Encrypted)");
|
||||
Program.ConsoleDesign(false);
|
||||
Program.ConsoleDesign(true);
|
||||
Console.WriteLine();
|
||||
type = Console.ReadLine();
|
||||
if (type == "2" || type == "4") FARC.FARCType |= KKdFARC.Type.GZip;
|
||||
if (type == "3" || type == "4") FARC.FARCType |= KKdFARC.Type.ECB ;
|
||||
}
|
||||
else if (type == "R") return;
|
||||
else FARC.Signature = KKdFARC.Farc.FArC;
|
||||
new KKdFARC(file, true).Pack(FARC.Signature);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,7 +1,8 @@
|
||||
using System;
|
||||
using KKdMainLib;
|
||||
using KKdBaseLib;
|
||||
using KKdMainLib.IO;
|
||||
using KKdA3DA = KKdMainLib.A3DA.A3DA;
|
||||
using KKdFARC = KKdMainLib.FARC;
|
||||
|
||||
namespace PD_Tool.Tools
|
||||
{
|
||||
@@ -10,71 +11,94 @@ namespace PD_Tool.Tools
|
||||
public static void Processor(bool JSON)
|
||||
{
|
||||
Console.Title = "A3DA Converter";
|
||||
Main.Choose(1, "a3da", out string[] FileNames);
|
||||
Program.Choose(1, "a3da", out string[] FileNames);
|
||||
if (FileNames.Length < 1) return;
|
||||
string filepath = "";
|
||||
string ext = "";
|
||||
|
||||
bool MP = true;
|
||||
bool MP = false;
|
||||
foreach (string file in FileNames)
|
||||
if (file.EndsWith(".mp" )) { MP = false; break; }
|
||||
if (file.EndsWith(".mp") || file.EndsWith(".json") || file.EndsWith(".farc")) { MP = true; break; }
|
||||
|
||||
Main.Format Format = Main.Format.NULL;
|
||||
if (!MP)
|
||||
Format Format = Format.NULL;
|
||||
string format = "";
|
||||
if (MP)
|
||||
{
|
||||
Console.Clear();
|
||||
Main.ConsoleDesign(true);
|
||||
Main.ConsoleDesign(" Choose type of format to export:");
|
||||
Main.ConsoleDesign(false);
|
||||
Main.ConsoleDesign("1. DT PS3");
|
||||
Main.ConsoleDesign("2. F PS3/PSV");
|
||||
Main.ConsoleDesign("3. FT PS4");
|
||||
Main.ConsoleDesign("4. F2nd PS3/PSV");
|
||||
Main.ConsoleDesign("5. MGF PSV");
|
||||
Main.ConsoleDesign("6. X PS4/PSV");
|
||||
Main.ConsoleDesign(false);
|
||||
Main.ConsoleDesign(true);
|
||||
Program.ConsoleDesign(true);
|
||||
Program.ConsoleDesign(" Choose type of format to export:");
|
||||
Program.ConsoleDesign(false);
|
||||
Program.ConsoleDesign("1. A3DA [DT/AC/F]");
|
||||
Program.ConsoleDesign("2. A3DC [DT/AC/F]");
|
||||
Program.ConsoleDesign("3. A3DA [AFT/FT] ");
|
||||
Program.ConsoleDesign("4. A3DC [AFT/FT] ");
|
||||
Program.ConsoleDesign("5. A3DC [F2] ");
|
||||
Program.ConsoleDesign("6. A3DC [MGF] ");
|
||||
Program.ConsoleDesign("7. A3DC [X] ");
|
||||
Program.ConsoleDesign(false);
|
||||
Program.ConsoleDesign(true);
|
||||
Console.WriteLine();
|
||||
string format = Console.ReadLine();
|
||||
if (format == "1") Format = Main.Format.DT ;
|
||||
else if (format == "2") Format = Main.Format.F ;
|
||||
else if (format == "3") Format = Main.Format.FT ;
|
||||
else if (format == "4") Format = Main.Format.F2LE;
|
||||
else if (format == "5") Format = Main.Format.MGF ;
|
||||
else if (format == "6") Format = Main.Format.X ;
|
||||
format = Console.ReadLine();
|
||||
if (format == "1") Format = Format.DT ;
|
||||
else if (format == "2") Format = Format.F ;
|
||||
else if (format == "3") Format = Format.FT ;
|
||||
else if (format == "4") Format = Format.FT ;
|
||||
else if (format == "5") Format = Format.F2LE;
|
||||
else if (format == "6") Format = Format.MGF ;
|
||||
else if (format == "7") Format = Format.X ;
|
||||
else return;
|
||||
}
|
||||
|
||||
KKdA3DA A;
|
||||
int state;
|
||||
foreach (string file in FileNames)
|
||||
try
|
||||
{
|
||||
ext = Path.GetExtension(file);
|
||||
filepath = file.Replace(ext, "");
|
||||
ext = ext.ToLower();
|
||||
Console.Title = "A3DA Converter: " + Path.GetFileNameWithoutExtension(file);
|
||||
A = new KKdA3DA();
|
||||
if (ext == ".a3da")
|
||||
{
|
||||
A.A3DAReader (filepath);
|
||||
A.MsgPackWriter(filepath, JSON);
|
||||
}
|
||||
else if (ext == ".mp" )
|
||||
{
|
||||
A.MsgPackReader(filepath, JSON);
|
||||
A.IO = File.OpenWriter(filepath + ".a3da", true);
|
||||
if (A.Data.Header.Format < Main.Format.F2LE)
|
||||
A.Data._.CompressF16 = Format == Main.Format.MGF ? 2 : 1;
|
||||
A.Data.Header.Format = Format;
|
||||
{
|
||||
A = new KKdA3DA();
|
||||
ext = Path.GetExtension(file);
|
||||
filepath = file.Replace(ext, "");
|
||||
ext = ext.ToLower();
|
||||
|
||||
if (A.Data.Header.Format > Main.Format.DT && A.Data.Header.Format != Main.Format.FT)
|
||||
A.A3DCWriter(filepath);
|
||||
else
|
||||
A.A3DAWriter();
|
||||
Console.Title = "A3DA Converter: " + Path.GetFileNameWithoutExtension(file);
|
||||
if (ext == ".farc")
|
||||
using (KKdFARC FARC = new KKdFARC(file))
|
||||
{
|
||||
if (!FARC.HeaderReader()) continue;
|
||||
if (!FARC.HasFiles) continue;
|
||||
|
||||
MsgPack A3DA = MsgPack.Null;
|
||||
byte[] data = null;
|
||||
for (int i = 0; i < FARC.Files.Length; i++)
|
||||
{
|
||||
data = FARC.FileReader(i);
|
||||
state = A.A3DAReader(data);
|
||||
if (state == 1)
|
||||
{
|
||||
A3DA = A.MsgPackWriter();
|
||||
A = new KKdA3DA();
|
||||
A.MsgPackReader(A3DA);
|
||||
A.Data._.CompressF16 = Format > Format.FT ? Format == Format.MGF ? 2 : 1 : 0;
|
||||
A.Data.Format = Format;
|
||||
FARC.Files[i].Data = (format != "1" && format != "3") ? A.A3DCWriter() : A.A3DAWriter();
|
||||
}
|
||||
}
|
||||
FARC.Save();
|
||||
}
|
||||
else if (ext == ".a3da")
|
||||
{
|
||||
state = A.A3DAReader(filepath);
|
||||
if (state == 1) A.MsgPackWriter(filepath, JSON);
|
||||
}
|
||||
catch (Exception e)
|
||||
{ Console.WriteLine(e); }
|
||||
else if (ext == ".mp" || ext == ".json")
|
||||
{
|
||||
A.MsgPackReader(filepath, ext == ".json");
|
||||
A.Data._.CompressF16 = Format > Format.FT ? Format == Format.MGF ? 2 : 1 : 0;
|
||||
A.Data.Format = Format;
|
||||
|
||||
File.WriteAllBytes(filepath + ".a3da", (format != "1" &&
|
||||
format != "3") ? A.A3DCWriter() : A.A3DAWriter());
|
||||
}
|
||||
A = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,40 @@
|
||||
using System;
|
||||
using KKdMainLib.IO;
|
||||
using KKdAet = KKdMainLib.Aet.Aet;
|
||||
|
||||
namespace PD_Tool.Tools
|
||||
{
|
||||
public class AET
|
||||
{
|
||||
public static void Processor(bool JSON)
|
||||
{
|
||||
Console.Title = "AET Converter";
|
||||
KKdAet Aet;
|
||||
Program.Choose(1, "bin", out string[] FileNames);
|
||||
if (FileNames.Length < 1) return;
|
||||
string filepath = "";
|
||||
string ext = "";
|
||||
|
||||
foreach (string file in FileNames)
|
||||
{
|
||||
Aet = new KKdAet();
|
||||
ext = Path.GetExtension(file);
|
||||
filepath = file.Replace(ext, "");
|
||||
ext = ext.ToLower();
|
||||
|
||||
Console.Title = "AET Converter: " + Path.GetFileNameWithoutExtension(file);
|
||||
if (ext == ".bin")
|
||||
{
|
||||
Aet. AETReader(filepath);
|
||||
Aet.MsgPackWriter(filepath, JSON);
|
||||
}
|
||||
else if (ext == ".mp" || ext == ".json")
|
||||
{
|
||||
Aet.MsgPackReader(filepath, ext == ".json");
|
||||
Aet. AETWriter(filepath);
|
||||
}
|
||||
Aet = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
using System;
|
||||
using KKdMainLib.IO;
|
||||
using KKdMainLib.F2;
|
||||
|
||||
namespace PD_Tool.Tools
|
||||
{
|
||||
public class BLT
|
||||
{
|
||||
public static void Processor()
|
||||
{
|
||||
Console.Title = "Bloom Converter";
|
||||
Bloom Bloom;
|
||||
Program.Choose(1, "blt", out string[] FileNames);
|
||||
if (FileNames.Length < 1) return;
|
||||
string filepath = "";
|
||||
string ext = "";
|
||||
|
||||
foreach (string file in FileNames)
|
||||
{
|
||||
Bloom = new Bloom();
|
||||
ext = Path.GetExtension(file);
|
||||
filepath = file.Replace(ext, "");
|
||||
ext = ext.ToLower();
|
||||
|
||||
Console.Title = "Bloom Converter: " + Path.GetFileNameWithoutExtension(file);
|
||||
if (ext == ".blt") { Bloom.BLTReader(filepath); Bloom.TXTWriter(filepath); }
|
||||
//else if (ext == ".txt") { Bloom.TXTReader(filepath); Bloom.BLTWriter(filepath); }
|
||||
Bloom = new Bloom();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
using System;
|
||||
using KKdMainLib.IO;
|
||||
using KKdMainLib.F2;
|
||||
|
||||
namespace PD_Tool.Tools
|
||||
{
|
||||
public class CCT
|
||||
{
|
||||
public static void Processor()
|
||||
{
|
||||
Console.Title = "Color Correction Converter";
|
||||
ColorCorrection ColorCorrection;
|
||||
Program.Choose(1, "cct", out string[] FileNames);
|
||||
if (FileNames.Length < 1) return;
|
||||
string filepath = "";
|
||||
string ext = "";
|
||||
|
||||
foreach (string file in FileNames)
|
||||
{
|
||||
ColorCorrection = new ColorCorrection();
|
||||
ext = Path.GetExtension(file);
|
||||
filepath = file.Replace(ext, "");
|
||||
ext = ext.ToLower();
|
||||
|
||||
Console.Title = "Color Correction Converter: " + Path.GetFileNameWithoutExtension(file);
|
||||
if (ext == ".cct") { ColorCorrection.CCTReader(filepath); ColorCorrection.TXTWriter(filepath); }
|
||||
//else if (ext == ".txt") { ColorCorrection.TXTReader(filepath); ColorCorrection.BLTWriter(filepath); }
|
||||
ColorCorrection = new ColorCorrection();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
+50
-35
@@ -1,50 +1,65 @@
|
||||
using System;
|
||||
using KKdMainLib;
|
||||
using KKdMainLib.IO;
|
||||
|
||||
namespace PD_Tool.Tools
|
||||
{
|
||||
public class DB
|
||||
{
|
||||
public static void Processor()
|
||||
public static void Processor(bool JSON)
|
||||
{
|
||||
Console.Title = "DataBank Converter";
|
||||
Main.Choose(1, "databank", out string[] FileNames);
|
||||
Program.Choose(1, "databank", out string[] FileNames);
|
||||
if (FileNames.Length < 1) return;
|
||||
string filepath = "";
|
||||
string ext = "";
|
||||
|
||||
DataBank DB;
|
||||
string[] file_split;
|
||||
int File_Checksum = 0, Get_Checksum;
|
||||
bool MP = true;
|
||||
foreach (string file in FileNames)
|
||||
//try
|
||||
{
|
||||
string filename = Path.GetFileNameWithoutExtension(file);
|
||||
file_split = filename.Split('_');
|
||||
DB = new DataBank();
|
||||
if (file_split.Length == 5 && file.EndsWith(".dat"))
|
||||
{
|
||||
if (int.TryParse(file_split[3], out File_Checksum))
|
||||
{
|
||||
Get_Checksum = DCC.CalculateChecksum(file);
|
||||
if (File_Checksum == Get_Checksum)
|
||||
{
|
||||
string filepath = file.Replace(filename + ".dat", "");
|
||||
Console.Title = "DataBank Converter: " + filename;
|
||||
DB.DBReader(file);
|
||||
DB.XMLWriter(filepath + file_split[0] + "_" +
|
||||
file_split[1] + "_" + file_split[2] + ".xml");
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (file.EndsWith(".xml"))
|
||||
{
|
||||
string filepath = file.Replace(Path.GetExtension(file), "");
|
||||
Console.Title = "DataBank Converter: " + Path.GetFileNameWithoutExtension(file);
|
||||
DB.XMLReader(file);
|
||||
DB.DBWriter(filepath);
|
||||
}
|
||||
}
|
||||
//catch (Exception e) { Console.WriteLine(e.Message); }
|
||||
if (file.EndsWith(".mp" )) { MP = false; break; }
|
||||
else if (file.EndsWith(".json")) { MP = false; break; }
|
||||
|
||||
string format = "1";
|
||||
if (MP)
|
||||
{
|
||||
Console.Clear();
|
||||
Program.ConsoleDesign(true);
|
||||
Program.ConsoleDesign(" Choose type of exporting file:");
|
||||
Program.ConsoleDesign(false);
|
||||
Program.ConsoleDesign("1. Compact");
|
||||
Program.ConsoleDesign("2. Normal");
|
||||
Program.ConsoleDesign(false);
|
||||
Program.ConsoleDesign(true);
|
||||
Console.WriteLine();
|
||||
format = Console.ReadLine();
|
||||
}
|
||||
|
||||
KKdMainLib.DataBank DB;
|
||||
string[] file_split;
|
||||
foreach (string file in FileNames)
|
||||
{
|
||||
ext = Path.GetExtension(file);
|
||||
filepath = file.Replace(ext, "");
|
||||
ext = ext.ToLower();
|
||||
|
||||
string filename = Path.GetFileNameWithoutExtension(file);
|
||||
file_split = filename.Split('_');
|
||||
DB = new KKdMainLib.DataBank();
|
||||
if (file_split.Length == 5 && ext == ".dat" && MP)
|
||||
{
|
||||
filepath = file.Replace(filename + ".dat", "");
|
||||
Console.Title = "DataBank Converter: " + filename;
|
||||
DB. DBReader(file);
|
||||
DB.MsgPackWriter(filepath + file_split[0] + "_" +
|
||||
file_split[1] + "_" + file_split[2], JSON, format != "2");
|
||||
}
|
||||
else if (ext == ".mp" || ext == ".json" && !MP)
|
||||
{
|
||||
Console.Title = "DataBank Converter: " + filename;
|
||||
DB.MsgPackReader(filepath, JSON);
|
||||
DB. DBWriter(filepath);
|
||||
}
|
||||
DB = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
using System;
|
||||
using KKdMainLib;
|
||||
using KKdBaseLib;
|
||||
using KKdMainLib.IO;
|
||||
using KKdDEX = KKdMainLib.DEX;
|
||||
|
||||
@@ -11,50 +11,61 @@ namespace PD_Tool.Tools
|
||||
{
|
||||
Console.Title = "DEX Converter";
|
||||
KKdDEX DEX;
|
||||
Main.Choose(1, "dex", out string[] FileNames);
|
||||
Program.Choose(1, "dex", out string[] FileNames);
|
||||
if (FileNames.Length < 1) return;
|
||||
string filepath = "";
|
||||
string ext = "";
|
||||
|
||||
bool MP = true;
|
||||
bool MP = true;
|
||||
bool _JSON = true;
|
||||
foreach (string file in FileNames)
|
||||
if (file.EndsWith(".mp" ))
|
||||
{ MP = false; break; }
|
||||
{ MP = false; break; }
|
||||
else if (file.EndsWith(".json"))
|
||||
{ _JSON = false; break; }
|
||||
|
||||
Console.Clear();
|
||||
string format = "";
|
||||
Main.ConsoleDesign(true);
|
||||
Main.ConsoleDesign(" Choose type of exporting file:");
|
||||
Main.ConsoleDesign(false);
|
||||
Main.ConsoleDesign("1. F/FT PS3/PS4/PSVita");
|
||||
Main.ConsoleDesign("2. F2nd PS3/PSVita");
|
||||
Main.ConsoleDesign("3. X PS4/PSVita");
|
||||
if (MP) Main.ConsoleDesign("9. MessagePack");
|
||||
Main.ConsoleDesign(false);
|
||||
Main.ConsoleDesign(true);
|
||||
Program.ConsoleDesign(true);
|
||||
Program.ConsoleDesign(" Choose type of exporting file:");
|
||||
Program.ConsoleDesign(false);
|
||||
Program.ConsoleDesign("1. F/FT PS3/PS4/PSVita");
|
||||
Program.ConsoleDesign("2. F2 PS3/PSVita");
|
||||
Program.ConsoleDesign("3. X PS4/PSVita");
|
||||
if ( MP && !JSON) Program.ConsoleDesign("9. MessagePack");
|
||||
if (_JSON && JSON) Program.ConsoleDesign("9. JSON");
|
||||
Program.ConsoleDesign(false);
|
||||
Program.ConsoleDesign(true);
|
||||
Console.WriteLine();
|
||||
format = Console.ReadLine();
|
||||
|
||||
Main.Format Format = Main.Format.NULL;
|
||||
if (format == "1") Format = Main.Format.F ;
|
||||
else if (format == "2") Format = Main.Format.F2LE;
|
||||
else if (format == "3") Format = Main.Format.X ;
|
||||
else if (format == "9" && MP ) Format = Main.Format.NULL;
|
||||
Format Format = Format.NULL;
|
||||
if (format == "1") Format = Format.F ;
|
||||
else if (format == "2") Format = Format.F2LE;
|
||||
else if (format == "3") Format = Format.X ;
|
||||
else if (format == "9" && (MP && _JSON)) Format = Format.NULL;
|
||||
else return;
|
||||
|
||||
int state;
|
||||
foreach (string file in FileNames)
|
||||
{
|
||||
DEX = new KKdDEX();
|
||||
ext = Path.GetExtension(file).ToLower();
|
||||
filepath = file.Replace(Path.GetExtension(file), "");
|
||||
|
||||
ext = Path.GetExtension(file);
|
||||
filepath = file.Replace(ext, "");
|
||||
ext = ext.ToLower();
|
||||
|
||||
Console.Title = "DEX Converter: " + Path.GetFileNameWithoutExtension(file);
|
||||
if (ext == ".bin" || ext == ".dex")
|
||||
DEX.DEXReader(filepath, ext);
|
||||
else DEX.MsgPackReader(filepath, JSON);
|
||||
state = DEX. DEXReader(filepath, ext );
|
||||
else state = DEX.MsgPackReader(filepath, JSON);
|
||||
|
||||
if (Format > Main.Format.NULL)
|
||||
DEX.DEXWriter(filepath, Format);
|
||||
else DEX.MsgPackWriter(filepath, JSON);
|
||||
if (state == 1)
|
||||
{
|
||||
if (Format > Format.NULL)
|
||||
DEX. DEXWriter(filepath, Format);
|
||||
else DEX.MsgPackWriter(filepath, JSON);
|
||||
}
|
||||
DEX = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,32 @@
|
||||
using System;
|
||||
using KKdMainLib.IO;
|
||||
using KKdMainLib.F2;
|
||||
|
||||
namespace PD_Tool.Tools
|
||||
{
|
||||
public class DFT
|
||||
{
|
||||
public static void Processor()
|
||||
{
|
||||
Console.Title = "DOF Converter";
|
||||
DOF DOF;
|
||||
Program.Choose(1, "dft", out string[] FileNames);
|
||||
if (FileNames.Length < 1) return;
|
||||
string filepath = "";
|
||||
string ext = "";
|
||||
|
||||
foreach (string file in FileNames)
|
||||
{
|
||||
DOF = new DOF();
|
||||
ext = Path.GetExtension(file);
|
||||
filepath = file.Replace(ext, "");
|
||||
ext = ext.ToLower();
|
||||
|
||||
Console.Title = "DOF Converter: " + Path.GetFileNameWithoutExtension(file);
|
||||
if (ext == ".dft") { DOF.DFTReader(filepath); DOF.TXTWriter(filepath); }
|
||||
//else if (ext == ".txt") { DOF.TXTReader(filepath); DOF.DFTWriter(filepath); }
|
||||
DOF = new DOF();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,5 @@
|
||||
using System;
|
||||
using System.IO;
|
||||
using KKdMainLib;
|
||||
using KKdSoundLib;
|
||||
|
||||
namespace PD_Tool.Tools
|
||||
@@ -10,29 +9,24 @@ namespace PD_Tool.Tools
|
||||
public static void Processor()
|
||||
{
|
||||
Console.Title = "DIVA Converter";
|
||||
Main.Choose(1, "diva", out string[] FileNames);
|
||||
Program.Choose(1, "diva", out string[] FileNames);
|
||||
if (FileNames.Length < 1) return;
|
||||
string filepath = "";
|
||||
string ext = "";
|
||||
|
||||
DIVA DIVA;
|
||||
foreach (string file in FileNames)
|
||||
try
|
||||
{
|
||||
string filepath = file.Replace(Path.GetExtension(file), "");
|
||||
string ext = Path.GetExtension(file);
|
||||
Console.Title = "DIVA Converter: " + Path.GetFileNameWithoutExtension(file);
|
||||
DIVA = new DIVA(filepath);
|
||||
switch (ext.ToLower())
|
||||
{
|
||||
case ".diva":
|
||||
DIVA.DIVAReader();
|
||||
break;
|
||||
case ".wav":
|
||||
DIVA.DIVAWriter();
|
||||
break;
|
||||
}
|
||||
GC.Collect();
|
||||
}
|
||||
catch (Exception e) { Console.WriteLine(e.Message); }
|
||||
{
|
||||
DIVA = new DIVA();
|
||||
ext = Path.GetExtension(file);
|
||||
filepath = file.Replace(ext, "");
|
||||
ext = ext.ToLower();
|
||||
|
||||
Console.Title = "DIVA Converter: " + Path.GetFileNameWithoutExtension(file);
|
||||
if (ext == ".diva") DIVA.DIVAReader(filepath);
|
||||
else if (ext == ".wav" ) DIVA.DIVAWriter(filepath);
|
||||
DIVA = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
using System;
|
||||
using KKdMainLib.IO;
|
||||
using KKdMainLib.F2;
|
||||
|
||||
namespace PD_Tool.Tools
|
||||
{
|
||||
public class LIT
|
||||
{
|
||||
public static void Processor()
|
||||
{
|
||||
Console.Title = "Light Converter";
|
||||
Light LIT;
|
||||
Program.Choose(1, "lit", out string[] FileNames);
|
||||
if (FileNames.Length < 1) return;
|
||||
string filepath = "";
|
||||
string ext = "";
|
||||
|
||||
foreach (string file in FileNames)
|
||||
{
|
||||
LIT = new Light();
|
||||
ext = Path.GetExtension(file);
|
||||
filepath = file.Replace(ext, "");
|
||||
ext = ext.ToLower();
|
||||
|
||||
Console.Title = "Light Converter: " + Path.GetFileNameWithoutExtension(file);
|
||||
if (ext == ".lit") { LIT.LITReader(filepath); LIT.TXTWriter(filepath); }
|
||||
//else if (ext == ".txt") { LIT.TXTReader(filepath); LIT.LITWriter(filepath); }
|
||||
LIT = new Light();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
using System;
|
||||
using KKdMainLib;
|
||||
using KKdMainLib.IO;
|
||||
|
||||
namespace PD_Tool.Tools
|
||||
{
|
||||
public class MOT
|
||||
{
|
||||
public static void Processor(bool JSON)
|
||||
{
|
||||
Console.Title = "MOT Converter";
|
||||
Mot Mot;
|
||||
Program.Choose(1, "bin", out string[] FileNames);
|
||||
if (FileNames.Length < 1) return;
|
||||
string filepath = "";
|
||||
string ext = "";
|
||||
|
||||
foreach (string file in FileNames)
|
||||
{
|
||||
Mot = new Mot();
|
||||
ext = Path.GetExtension(file);
|
||||
filepath = file.Replace(ext, "");
|
||||
ext = ext.ToLower();
|
||||
|
||||
Console.Title = "MOT Converter: " + Path.GetFileNameWithoutExtension(file);
|
||||
if (ext == ".bin")
|
||||
{
|
||||
Mot. MOTReader(filepath);
|
||||
Mot.MsgPackWriter(filepath, JSON);
|
||||
}
|
||||
else if (ext == ".mp" || ext == ".json")
|
||||
{
|
||||
Mot.MsgPackReader(filepath, ext == ".json");
|
||||
Mot. MOTWriter(filepath);
|
||||
}
|
||||
Mot = new Mot();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,4 @@
|
||||
using System;
|
||||
using KKdMainLib;
|
||||
using KKdMainLib.IO;
|
||||
using KKdSTR = KKdMainLib.STR;
|
||||
|
||||
@@ -10,15 +9,16 @@ namespace PD_Tool.Tools
|
||||
public static void Processor(bool JSON)
|
||||
{
|
||||
Console.Title = "STR Converter";
|
||||
Main.Choose(1, "str", out string[] FileNames);
|
||||
Program.Choose(1, "str", out string[] FileNames);
|
||||
|
||||
KKdSTR Data;
|
||||
string filepath = "";
|
||||
string ext = "";
|
||||
foreach (string file in FileNames)
|
||||
{
|
||||
filepath = file.Replace(Path.GetExtension(file), "");
|
||||
ext = Path.GetExtension(file).ToLower();
|
||||
ext = Path.GetExtension(file);
|
||||
filepath = file.Replace(ext, "");
|
||||
ext = ext.ToLower();
|
||||
Data = new KKdSTR();
|
||||
|
||||
Console.Title = "PD_Tool: Converter Tools: STR Reader: " +
|
||||
@@ -28,11 +28,12 @@ namespace PD_Tool.Tools
|
||||
Data.STRReader (filepath, ext);
|
||||
Data.MsgPackWriter(filepath, JSON);
|
||||
}
|
||||
else if (ext == ".mp")
|
||||
else if (ext == ".json" || ext == ".mp")
|
||||
{
|
||||
Data.MsgPackReader(filepath, JSON);
|
||||
Data.MsgPackReader(filepath, ext == ".json");
|
||||
Data.STRWriter (filepath);
|
||||
}
|
||||
Data = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
using System;
|
||||
using System.IO;
|
||||
using KKdMainLib;
|
||||
using KKdVAG = KKdSoundLib.VAG;
|
||||
|
||||
namespace PD_Tool.Tools
|
||||
@@ -10,7 +9,11 @@ namespace PD_Tool.Tools
|
||||
public static void Processor()
|
||||
{
|
||||
Console.Title = "VAG Converter";
|
||||
Main.Choose(1, "vag", out string[] FileNames);
|
||||
Program.Choose(1, "vag", out string[] FileNames);
|
||||
if (FileNames.Length < 1) return;
|
||||
string filepath = "";
|
||||
string ext = "";
|
||||
|
||||
bool InputWAV = false;
|
||||
foreach (string file in FileNames)
|
||||
if (Path.GetExtension(file) == ".wav")
|
||||
@@ -20,40 +23,31 @@ namespace PD_Tool.Tools
|
||||
if (InputWAV)
|
||||
{
|
||||
Console.Clear();
|
||||
Main.ConsoleDesign(true);
|
||||
Main.ConsoleDesign(" Choose type of format to export:");
|
||||
Main.ConsoleDesign(false);
|
||||
Main.ConsoleDesign("1. VAG (Downmix to 1 ch)");
|
||||
Main.ConsoleDesign("2. HEVAG");
|
||||
Main.ConsoleDesign(false);
|
||||
Main.ConsoleDesign(true);
|
||||
Program.ConsoleDesign(true);
|
||||
Program.ConsoleDesign(" Choose type of format to export:");
|
||||
Program.ConsoleDesign(false);
|
||||
Program.ConsoleDesign("1. VAG (Downmix to 1 ch)");
|
||||
Program.ConsoleDesign("2. HEVAG");
|
||||
Program.ConsoleDesign(false);
|
||||
Program.ConsoleDesign(true);
|
||||
Console.WriteLine();
|
||||
string format = Console.ReadLine();
|
||||
HE_VAG = format != "2";
|
||||
HE_VAG = format == "2";
|
||||
}
|
||||
|
||||
KKdVAG VAG;
|
||||
foreach (string file in FileNames)
|
||||
try
|
||||
{
|
||||
string ext = Path.GetExtension(file);
|
||||
string filepath = file.Remove(file.Length - ext.Length);
|
||||
Console.Title = "VAG Converter: " +
|
||||
Path.GetFileNameWithoutExtension(file);
|
||||
VAG = new KKdVAG() { file = filepath };
|
||||
switch (ext.ToLower())
|
||||
{
|
||||
case ".vag":
|
||||
VAG.VAGReader();
|
||||
VAG.WAVWriter();
|
||||
break;
|
||||
case ".wav":
|
||||
VAG.WAVReader();
|
||||
VAG.VAGWriter(HE_VAG);
|
||||
break;
|
||||
}
|
||||
}
|
||||
catch (Exception e) { Console.WriteLine(e.Message); }
|
||||
{
|
||||
VAG = new KKdVAG();
|
||||
ext = Path.GetExtension(file);
|
||||
filepath = file.Replace(ext, "");
|
||||
ext = ext.ToLower();
|
||||
|
||||
Console.Title = "VAG Converter: " + Path.GetFileNameWithoutExtension(file);
|
||||
if (ext == ".vag") { VAG.VAGReader(filepath); VAG.WAVWriter(filepath ); }
|
||||
else if (ext == ".wav") { VAG.WAVReader(filepath); VAG.VAGWriter(filepath, HE_VAG); }
|
||||
VAG = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -8,11 +8,14 @@ A simple tool for working with Project Diva DT/FT/F/F2/X files
|
||||
- `FARC Extract/Create`
|
||||
- `DIVAFILE Encrypt/Decrypt`
|
||||
- `DB_Tools`
|
||||
- `Aet DB Converter`
|
||||
- `Auth DB Converter`
|
||||
- `Spr DB Converter`
|
||||
- `Converting Tools`
|
||||
- `A3DA Converter`
|
||||
- `DataBank Converter`
|
||||
- `DEX Converter`
|
||||
- `DIVA Converter`
|
||||
- `STR Converter`
|
||||
- `VAG Converter`
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user