public static Stream EnsureUnpacked(Stream s)
{
var reader = new StructReader(s, System.Text.Encoding.ASCII, true);
var streamStart = s.Position;
var version = reader.ReadSingle(); //read just version
s.Position = streamStart; //back to start for further processing
if (version >= 1.44f)
{
var header = reader.ReadStruct <DLF_IO_HEADER>(); //read full header
MemoryStream ms = new MemoryStream();
StructWriter writer = new StructWriter(ms, System.Text.Encoding.ASCII, true);
writer.WriteStruct(header); //write header
byte[] restOfFile = reader.ReadBytes((int)(reader.BaseStream.Length - reader.BaseStream.Position));
byte[] unpacked = ArxIO.Unpack(restOfFile);
writer.Write(unpacked); //write unpacked rest
s.Dispose(); //close old stream
ms.Position = 0;
return(ms);
}
return(s); //no need to unpack, return input stream
}
public static void SaveCache()
{
if (!CacheReady)
{
return;
}
try {
TLBCache Cache = new TLBCache()
{
Signature = "TLBC",
Original = Program.Cache.Keys.OfType <string>().ToArray(),
Translations = Program.Cache.Values.OfType <string>().ToArray(),
ManualString = ForceDialogues.Keys.OfType <string>().ToArray(),
ManualChecked = ForceDialogues.Values.OfType <bool>().ToArray()
};
if (File.Exists(CachePath))
{
File.Delete(CachePath);
}
using (StructWriter Writer = new StructWriter(CachePath)) {
Writer.WriteStruct(ref Cache);
Writer.Close();
}
} catch { }
SaveTask();
}
public static byte[] DoImplode(byte[] bytes)
{
MemoryStream output = new MemoryStream();
var header = new ImplodeHeader();
header.literalSize = ImplodeLiteralSize.Fixed;
header.dictSize = ImplodeDictSize.Size1024;
using (var sw = new StructWriter(output, Encoding.UTF8, true))
{
sw.WriteStruct(header);
}
BitStream bits = new BitStream();
for (int i = 0; i < bytes.Length; i++)
{
bits.WriteFixedLiteral(bytes[i]);
}
bits.WriteEOS();
while (bits.ByteReady())
{
output.WriteByte(bits.GetByte());
}
output.WriteByte(bits.GetBytePadded());
return(output.ToArray());
}
ColumnWriterDetails GetStructColumnWriter()
{
var columnWriter = new StructWriter(_bufferFactory, 0);
var state = new List <object>();
var structColumnType = new Protocol.ColumnType
{
Kind = Protocol.ColumnTypeKind.Struct
};
foreach (var column in _columnWriters)
{
structColumnType.FieldNames.Add(column.PropertyName);
structColumnType.SubTypes.Add(column.ColumnWriter.ColumnId);
}
return(new ColumnWriterDetails
{
PropertyName = _typeName,
ColumnWriter = columnWriter,
AddValueToState = classInstance =>
{
state.Add(classInstance);
},
WriteValuesFromState = () =>
{
columnWriter.AddBlock(state);
state.Clear();
},
ColumnType = structColumnType
});
}
private void WriteString(StructWriter Stream, string Content)
{
byte[] Buffer = Encoding.UTF8.GetBytes(Content);
WriteNum(Stream, Buffer.LongLength);
Stream.Write(Buffer, 0, Buffer.Length);
}
public byte[] Export(string[] Strings)
{
uint EntryLen = (uint)Tools.GetStructLength(new Entry());
byte[] NewScript = new byte[this.Header.TextTableOffset];
Array.Copy(Script, NewScript, NewScript.Length);
MemoryStream StringBuffer = new MemoryStream();
Entry[] EntryArr = Entries.ToArray();
StructWriter Writer = new StructWriter(StringBuffer, Encoding.Unicode);
uint Length = 0;
for (int i = 0; i < Strings.Length; i++)
{
dynamic Struct = EntryArr[i];
Struct.TextPos = Length;
Struct.TextUniLength = (uint)Strings[i].Length;
Overwrite(ref NewScript, Tools.BuildStruct(ref Struct), Header.ByteCodeLength + Header.ByteCodeStart + (EntryLen * (uint)i));
Length += Struct.TextUniLength + 1;
Writer.Write(Strings[i], StringStyle.UCString);
}
Header.TextUniTableLength = (uint)StringBuffer.Length / 2;
Header.TextTableLength = (uint)StringBuffer.Length;
dynamic H = Header;
Tools.BuildStruct(ref H).CopyTo(NewScript, 0);
NewScript = NewScript.Concat(StringBuffer.ToArray()).ToArray();
Writer.Close();
StringBuffer?.Close();
return(NewScript);
}
public static Stream EnsurePacked(Stream s)
{
s.Position = 0;
StructReader reader = new StructReader(s);
MemoryStream ms = new MemoryStream();
StructWriter writer = new StructWriter(ms, System.Text.Encoding.ASCII, true);
var header = reader.ReadStruct <FTS_IO_UNIQUE_HEADER>();
writer.WriteStruct(header);
for (int i = 0; i < header.count; i++)
{
writer.WriteStruct(reader.ReadStruct <FTS_IO_UNIQUE_HEADER2>());
}
byte[] restOfFile = reader.ReadBytes((int)(reader.BaseStream.Length - reader.BaseStream.Position));
byte[] packed = ArxIO.Pack(restOfFile);
ms.Write(packed, 0, packed.Length);
ms.Position = 0;
s.Dispose();
return(ms);
}
public byte[] Export(string[] Content)
{
using (var Strm = new MemoryStream())
using (StructWriter Writer = new StructWriter(Strm, Encoding: Encoding))
{
var File = new TextDataFormat();
File.Content = Content;
File.Count = Content.Length;
File.Offsets = new TextDataEntryOffset[File.Count];
var Offset = 16 + (16 * File.Count);
for (int i = 0; i < Content.Length; i++)
{
File.Offsets[i] = new TextDataEntryOffset()
{
Offset = Offset
};
Offset += Encoding.GetByteCount(Content[i] + '\x0');
}
Writer.WriteStruct(ref File);
Writer.Flush();
foreach (var String in Content)
{
Writer.WriteString(String, StringStyle.CString);
}
return(Strm.ToArray());
}
}
public byte[] Export(string[] Content)
{
var NewHeader = new HeaderFooter();
Tools.CopyStruct(Header, ref NewHeader);
using (MemoryStream OriScript = new MemoryStream(Script))
using (MemoryStream Stream = new MemoryStream())
using (StructWriter Writer = new StructWriter(Stream, Header.Endian == 'B', Encoding)) {
NewHeader.StructOffset = 0;
OriScript.Position = Header.StructOffset;
byte[] StructData = new byte[Align(Header.StructCount * Header.StructSize)];
OriScript.Read(StructData, 0, StructData.Length);
NewHeader.TypesOffset = (uint)StructData.Length;
OriScript.Position = Header.TypesOffset;
byte[] TypeData = new byte[Align(Header.TypesCount * Tools.GetStructLength(new TypeDescriptor()))];
OriScript.Read(TypeData, 0, TypeData.Length);
NewHeader.StringOffset = (uint)(NewHeader.TypesOffset + TypeData.Length);
byte[] StrData;
using (MemoryStream StrStream = new MemoryStream())
using (StructWriter StrWriter = new StructWriter(StrStream, Writer.BigEndian, Encoding)) {
Dictionary <string, uint> OffsetMap = new Dictionary <string, uint>();
for (int i = 0; i < Content.Length; i++)
{
if (OffsetMap.ContainsKey(Content[i]))
{
var Offset = OffsetMap[Content[i]];
BitConverter.GetBytes(Offset).CopyTo(StructData, OffsetPos[i]);
}
else
{
BitConverter.GetBytes((uint)StrWriter.Position).CopyTo(StructData, OffsetPos[i]);
OffsetMap[Content[i]] = (uint)StrWriter.Position;
StrWriter.Write(Content[i], StringStyle.CString);
}
}
StrWriter.Flush();
StrData = new byte[Align(StrStream.Length)];
StrStream.ToArray().CopyTo(StrData, 0);
}
Writer.Write(StructData);
Writer.Write(TypeData);
Writer.Write(StrData);
Writer.WriteStruct(ref NewHeader);
Writer.Flush();
return(Stream.ToArray());
}
}
public void WriteTo(StructWriter writer)
{
writer.WriteStruct(header);
for (int i = 0; i < paths.Length; i++)
{
writer.WriteStruct(paths[i]);
}
}
static public void Export(File[] Files, Stream Output, bool CloseStreams = true)
{
StructWriter Writer = new StructWriter(Output, Encoding: Encoding.Unicode);
uint DataInfoLen = 0;
foreach (File f in Files)
{
DataInfoLen += (uint)Tools.GetStructLength(f, Encoding.Unicode);
}
ArcHeader Header = new ArcHeader()
{
Count = (uint)Files.LongLength,
BaseOffset = DataInfoLen
};
Writer.WriteStruct(ref Header);
uint Ptr = 0;
for (uint i = 0; i < Files.LongLength; i++)
{
Files[i].Offset = Ptr;
Files[i].Length = (uint)Files[i].Content.Length;
Ptr += Files[i].Length;
Writer.WriteStruct(ref Files[i]);
}
for (uint i = 0; i < Files.LongLength; i++)
{
int Readed = 0;
uint TotalLen = 0;
byte[] Buffer = new byte[1024 * 1024];
do
{
Readed = Files[i].Content.Read(Buffer, 0, Buffer.Length);
Output.Write(Buffer, 0, Readed);
TotalLen += (uint)Readed;
} while (Readed > 0);
Output.Flush();
//System.Diagnostics.Debug.Assert(TotalLen == Files[i].Length);
if (CloseStreams)
{
Files[i].Content.Close();
}
}
if (CloseStreams)
{
Writer.Close();
}
}
public static void Repack(File[] Files, Stream Output, bool CloseStreams = true)
{
if ((from x in Files where x.FileName == HeaderInfo select x).Count() != 1)
{
throw new Exception("Header Info Not Found");
}
byte[] HInfo = new byte[0x7F8];
File tmp = (from x in Files where x.FileName == HeaderInfo select x).First();
tmp.Content.Read(HInfo, 0, HInfo.Length);
tmp.Content.Close();
Files = (from x in Files where x.FileName != HeaderInfo select x).ToArray();
StructWriter Writer = new StructWriter(Output, Encoding: Encoding.ASCII);
PACHeader Header = new PACHeader()
{
Signature = "PAC ",
FileCount = (uint)Files.Length,
Dummy = HInfo
};
Writer.WriteStruct(ref Header);
uint TotalHeaderLen = (uint)((Tools.GetStructLength(new File()) * Files.Length) + Tools.GetStructLength(Header));
for (uint i = 0, x = 0; i < Files.Length; i++)
{
tmp = new File()
{
FileName = Files[i].FileName,
Length = (uint)Files[i].Content.Length,
Offset = x + TotalHeaderLen
};
Writer.WriteStruct(ref tmp);
x += tmp.Length;
}
for (uint i = 0; i < Files.Length; i++)
{
Files[i].Content.CopyTo(Writer.BaseStream);
if (CloseStreams)
{
Files[i].Content.Close();
}
}
Writer.Flush();
if (CloseStreams)
{
Writer.Close();
}
}
public void WriteTo(StructWriter writer)
{
writer.WriteStruct(data);
for (int i = 0; i < linkedAnchors.Length; i++)
{
writer.Write(linkedAnchors[i]);
}
}
public void write(DataWriter i_writer)
{
i_writer.writeAscii(this.szName, 20);
i_writer.writeShort(this.nParentNo);
i_writer.writeShort(this.nChildNo);
i_writer.writeByte(this.cbKind);
i_writer.writeShort(this.unIKTarget);
StructWriter.write(this.vec3Position, i_writer);
return;
}
public void write(DataWriter i_writer)
{
StructWriter.write(this.vec3Pos, i_writer);
StructWriter.write(this.vec3Normal, i_writer);
StructWriter.write(this.uvTex, i_writer);
i_writer.writeUnsignedShort(this.unBoneNo[0]);
i_writer.writeUnsignedShort(this.unBoneNo[1]);
i_writer.write(this.cbWeight);
i_writer.write(this.cbEdge);
return;
}
public static byte[] BuildStruct <T>(ref T Struct, bool BigEndian = false, Encoding Encoding = null)
{
MemoryStream Stream = new MemoryStream();
StructWriter Writer = new StructWriter(Stream, BigEndian, Encoding);
Writer.WriteStruct(ref Struct);
byte[] Result = Stream.ToArray();
Writer.Close();
Stream?.Close();
return(Result);
}
public void write(DataWriter i_writer)
{
StructWriter.write(this.col4Diffuse, i_writer);
i_writer.writeFloat(this.fShininess);
StructWriter.write(this.col3Specular, i_writer);
StructWriter.write(this.col3Ambient, i_writer);
i_writer.writeByte(this.toon_index); // toon??.bmp // 0.bmp:0xFF, 1(01).bmp:0x00 ・・・ 10.bmp:0x09
i_writer.writeByte(this.edge_flag); // 輪郭、影
i_writer.writeInt(this.ulNumIndices);
i_writer.writeAscii(this.szTextureFileName, 20);
return;
}
public static Stream BuildEntries(NPK3Entry[] Entries)
{
Stream Output = new MemoryStream();
StructWriter Writer = new StructWriter(Output, Encoding: Encoding);
for (int i = 0; i < Entries.Length; i++)
{
var Entry = Entries[i];
Writer.WriteStruct(ref Entry);
}
Output.Position = 0;
return(Output);
}
private void SaveSettings()
{
Settings.Signature = Signature;
Settings.Version = SettingsVersion;
Settings.Blacklist = Settings.Blacklist.Distinct().ToArray();
using (Stream WriterStream = new StreamWriter(SettingsPath).BaseStream)
using (StructWriter Writer = new StructWriter(WriterStream)) {
Writer.WriteStruct(ref Settings);
Writer.Close();
}
}
public void WriteTo(StructWriter writer)
{
writer.WriteStruct(sceneInfo);
for (int i = 0; i < polygons.Length; i++)
{
writer.WriteStruct(polygons[i]);
}
for (int i = 0; i < anchors.Length; i++)
{
writer.Write(anchors[i]);
}
}
public void WriteTo(Stream s)
{
StructWriter writer = new StructWriter(s);
writer.WriteStruct(header);
for (int i = 0; i < uniqueHeaders.Length; i++)
{
writer.WriteStruct(uniqueHeaders[i]);
}
writer.WriteStruct(sceneHeader);
for (int i = 0; i < textureContainers.Length; i++)
{
writer.WriteStruct(textureContainers[i]);
}
for (int z = 0; z < sceneHeader.sizez; z++)
{
for (int x = 0; x < sceneHeader.sizex; x++)
{
int index = z * sceneHeader.sizex + x;
cells[index].WriteTo(writer);
}
}
for (int i = 0; i < anchors.Length; i++)
{
anchors[i].WriteTo(writer);
}
for (int i = 0; i < portals.Length; i++)
{
writer.WriteStruct(portals[i]);
}
for (int i = 0; i < rooms.Length; i++)
{
rooms[i].WriteTo(writer);
}
for (int i = 0, index = 0; i < rooms.Length; i++)
{
for (int j = 0; j < rooms.Length; j++, index++)
{
writer.WriteStruct(roomDistances[index]);
}
}
}
public void WriteTo(StructWriter writer)
{
writer.WriteStruct(data);
for (int i = 0; i < portals.Length; i++)
{
writer.Write(portals[i]);
}
for (int i = 0; i < polygons.Length; i++)
{
writer.WriteStruct(polygons[i]);
}
}
public void write(DataWriter i_writer)
{
i_writer.writeAscii(this.joint_name, 20); // 諸データ：名称 // 右髪1
i_writer.writeInt(this.joint_rigidbody_a); // 諸データ：剛体A
i_writer.writeInt(this.joint_rigidbody_b); // 諸データ：剛体B
StructWriter.write(this.joint_pos, i_writer); // 諸データ：位置(x, y, z) // 諸データ：位置合せでも設定可
StructWriter.write(this.joint_rot, i_writer); // 諸データ：回転(rad(x), rad(y), rad(z))
StructWriter.write(this.constrain_pos_1, i_writer); // 制限：移動1(x, y, z)
StructWriter.write(this.constrain_pos_2, i_writer); // 制限：移動2(x, y, z)
StructWriter.write(this.constrain_rot_1, i_writer); // 制限：回転1(rad(x), rad(y), rad(z))
StructWriter.write(this.constrain_rot_2, i_writer); // 制限：回転2(rad(x), rad(y), rad(z))
StructWriter.write(this.spring_pos, i_writer); // ばね：移動(x, y, z)
StructWriter.write(this.spring_rot, i_writer); // ばね：回転(rad(x), rad(y), rad(z))
return;
}
public byte[] Export(StringEntry[] Strings)
{
ScriptHeader NewHeader = new ScriptHeader();
Tools.CopyStruct(Header, ref NewHeader);
MemoryStream UnkData = new MemoryStream();
MemoryStream OffsetData = new MemoryStream();
MemoryStream StringData = new MemoryStream();
MemoryStream Reader = new MemoryStream(Script);
Reader.Seek(0x10, SeekOrigin.Begin);
Algo.CopyStream(Reader, UnkData, NewHeader.UnkCount * 8);
Reader.Close();
StructWriter OffsetWriter = new StructWriter(OffsetData, false, Encoding);
StructWriter StringWriter = new StructWriter(StringData, false, Encoding);
for (uint i = 0; i < EntryCount; i++)
{
OffsetWriter.Write((uint)StringWriter.BaseStream.Length);
StringWriter.WriteStruct(ref Strings[i]);
}
OffsetWriter.Seek(0, SeekOrigin.Begin);
StringWriter.Seek(0, SeekOrigin.Begin);
NewHeader.ScriptLength = (uint)(OffsetWriter.BaseStream.Length + StringWriter.BaseStream.Length + UnkData.Length);
NewHeader.OffsetTable = (uint)UnkData.Length;
NewHeader.StringTable = (uint)(UnkData.Length + OffsetData.Length);
byte[] Output = new byte[0x10 + UnkData.Length + OffsetData.Length + StringData.Length];
Tools.BuildStruct(ref NewHeader, false, Encoding).CopyTo(Output, 0);
UnkData.ToArray().CopyTo(Output, 0x10);
OffsetData.ToArray().CopyTo(Output, 0x10 + UnkData.Length);
StringData.ToArray().CopyTo(Output, 0x10 + UnkData.Length + OffsetData.Length);
UnkData.Close();
StringWriter.Close();
OffsetWriter.Close();
return(Compress(Output));
}
private void BuildStringData(string[] Strings, out byte[] StringTable, out int[] Offsets)
{
Offsets = new int[StrCount];
MemoryStream StrData = new MemoryStream();
StructWriter Writer = new StructWriter(StrData);
for (int i = 0; i < StrCount; i++)
{
Offsets[i] = (int)Writer.BaseStream.Length;
StrEntry Entry = new StrEntry();
Entry.Content = Strings[i];
Writer.WriteStruct(ref Entry);
}
StringTable = StrData.ToArray();
Writer.Close();
StrData?.Close();
}
internal static void SaveTask()
{
try {
if (File.Exists(TaskPath))
{
File.Delete(TaskPath);
}
if (TaskInfo.LastTaskPos > 0)
{
using (StructWriter Writer = new StructWriter(TaskPath)) {
Writer.WriteStruct(ref TaskInfo);
Writer.Close();
}
}
} catch { }
}
public void WriteTo(Stream s)
{
using (StructWriter writer = new StructWriter(s, System.Text.Encoding.ASCII, true))
{
writer.WriteStruct(header);
for (int i = 0; i < scenes.Length; i++)
{
writer.WriteStruct(scenes[i]);
}
for (int i = 0; i < inters.Length; i++)
{
writer.WriteStruct(inters[i]);
}
if (header.lighting != 0)
{
writer.WriteStruct(lightingHeader);
for (int i = 0; i < lightColors.Length; i++)
{
writer.Write(lightColors[i]);
}
}
for (int i = 0; i < lights.Length; i++)
{
writer.WriteStruct(lights[i]);
}
for (int i = 0; i < fogs.Length; i++)
{
writer.WriteStruct(fogs[i]);
}
//write back nodes data
writer.Write(nodesData);
for (int i = 0; i < paths.Length; i++)
{
paths[i].WriteTo(writer);
}
}
}
private void WritePadBytes(StructWriter sw, long curlen, long wantedlen)
{
long padlength = wantedlen - curlen;
if (padlength <= 0)
{
return;
}
byte[] buffer = new byte[padlength];
for (int padidx = 0; padidx < buffer.Length; padidx++)
{
buffer[padidx] = 0;
}
sw.Write(buffer);
}
public void WriteTo(Stream s)
{
var writer = new StructWriter(s);
writer.WriteStruct(header);
for (int i = 0; i < lights.Length; i++)
{
writer.WriteStruct(lights[i]);
}
writer.WriteStruct(lightingHeader);
for (int i = 0; i < lightColors.Length; i++)
{
writer.Write(lightColors[i]);
}
}
public FieldInvoke GetOffsetWork()
{
return(new FieldInvoke(
(Stream, FromReader, Struct) => {
XBXHeader Header = Struct;
uint Count = (Header.EntryLen * Header.EntriesCount);
if (FromReader)
{
StructReader Reader = new StructReader(Stream);
Header.Offsets = new uint[Count];
for (uint i = 0; i < Count; i++)
{
Header.Offsets[i] = Reader.ReadRawType(Const.UINT32);
}
Header.IsString = new bool[Header.EntryLen];
for (uint i = 0; i < Header.EntryLen; i++)
{
Header.IsString[i] = IsString(Stream, Header.Offsets[i] + Header.StrPos);
}
}
else
{
for (uint i = 0, x = 0; i < Header.Offsets.Length; i++)
{
if (!Header.IsString[i % Header.EntryLen])
{
continue;
}
Header.Offsets[i] = x;
x += (uint)Encoding.GetByteCount(Header.Strings[i]) + 1;
}
StructWriter Writer = new StructWriter(Stream);
for (uint i = 0; i < Count; i++)
{
Writer.WriteRawType(Const.UINT32, Header.Offsets[i]);
}
}
return Header;
}));
}
