Public-Mirror/GARbro-mirror
1
0
Fork 0
mirror of https://github.com/crskycode/GARbro.git synced 2024-11-24 06:05:35 +08:00
Code Issues Projects Releases Wiki Activity
59259051fe
GARbro-mirror/ArcFormats/rUGP/ArcRIO.cs

1386 lines
44 KiB
C#
Raw Normal View History

(rUGP): initial implementation.
2016-11-08 16:30:59 +08:00
//! \file ArcRIO.cs
//! \date Thu Nov 03 13:21:56 2016
//! \brief rUGP engine resource archive.
//
// Copyright (C) 2016 by morkt
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
//
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
namespace GameRes.Formats.Rugp
{
[Export(typeof(ArchiveFormat))]
public class RioOpener : ArchiveFormat
{
public override string Tag { get { return "RIO"; } }
public override string Description { get { return "rUGP engine resource archive"; } }
public override uint Signature { get { return 0; } }
public override bool IsHierarchic { get { return false; } }
public override bool CanWrite { get { return false; } }
public RioOpener ()
{
Signatures = new uint[] { CRioArchive.RioSignature, 0 };
}
static readonly Dictionary<string, string> SupportedClasses = new Dictionary<string, string> {
{ "CRip007", "image" },
{ "CRip", "image" },
{ "CS5i", "image" },
{ "CIcon", "image" },
{ "CRsa", "script" },
{ "CVmFunc", "script" },
{ "CrelicHicompAudio", "audio" },
};
public override ArcFile TryOpen (ArcView file)
{
using (var reader = RioReader.Create (file))
{
if (null == reader)
return null;
reader.DeserializeRelic();
var nodes = reader.Arc.LoadArray.OfType<COceanNode>();
var types = nodes.Select (n => n.ClassName).Distinct();
(RioOpener.TryOpen): use LINQ syntax.
2016-12-15 14:54:09 +08:00
var dir = from node in nodes
where SupportedClasses.ContainsKey (node.ClassName)
select new Entry {
Name = node.Name,
Type = SupportedClasses[node.ClassName],
Offset = node.Offset,
Size = node.Size
};
(rUGP): initial implementation.
2016-11-08 16:30:59 +08:00
if (!dir.Any())
return null;
return new ArcFile (file, this, dir.ToList());
}
}
}
internal sealed class RioReader : IDisposable
{
IBinaryStream m_input;
IBinaryStream m_toc;
CRioArchive m_arc;
bool m_read_toc;
CrelicUnitedGameProject m_relic;
const uint IciKey = 0xB29D5A0C;
public CRioArchive Arc { get { return m_arc; } }
public CrelicUnitedGameProject DeserializeRelic ()
{
if (!m_read_toc)
{
m_read_toc = true;
m_relic = m_arc.DeserializeRoot() as CrelicUnitedGameProject;
if (m_toc != m_input)
{
m_toc.Dispose();
m_toc = m_input;
m_arc.SetSource (m_input);
}
}
return m_relic;
}
static public RioReader Create (ArcView file)
{
if (CRioArchive.RioSignature == file.View.ReadUInt32 (0))
return new RioReader (file);
use HasExtension method instead of string.EndsWith.
2017-04-11 03:15:13 +08:00
if (file.Name.HasExtension (".ici"))
(rUGP): initial implementation.
2016-11-08 16:30:59 +08:00
return null;
var ici_name = file.Name + ".ici";
if (!VFS.FileExists (ici_name))
{
ici_name = Path.ChangeExtension (file.Name, ".ici");
if (!VFS.FileExists (ici_name))
return null;
}
byte[] ici_data;
using (var ici = VFS.OpenBinaryStream (ici_name))
ici_data = ReadIci (ici, IciKey);
CObjectArcMan arc_man;
using (var ici = new BinMemoryStream (ici_data))
{
var rio = new CRioArchive (ici);
arc_man = rio.DeserializeRoot() as CObjectArcMan;
if (null == arc_man)
return null;
}
var arc_object = arc_man.ArcList.FirstOrDefault();
(VFS.IsPathEqualsToFileName): new method.
2016-12-29 20:19:28 +08:00
if (null == arc_object || !VFS.IsPathEqualsToFileName (file.Name, arc_object.RioName))
(rUGP): initial implementation.
2016-11-08 16:30:59 +08:00
return null;
return new RioReader (arc_man, file);
}
private RioReader (ArcView file)
{
m_input = file.CreateStream();
m_toc = m_input;
m_arc = new CRioArchive (m_input);
}
private RioReader (CObjectArcMan arc_man, ArcView file)
{
long toc_offset = arc_man.TocOffset;
uint signature = file.View.ReadUInt32 (toc_offset);
int shift = 0;
if (signature != CRioArchive.EncryptedSignature)
{
toc_offset *= 2;
signature = file.View.ReadUInt32 (toc_offset);
if (signature != CRioArchive.EncryptedSignature)
throw new InvalidFormatException ("CPmArchive signature not found");
shift = 1;
}
m_input = file.CreateStream();
m_toc = file.CreateStream (toc_offset, (uint)arc_man.TocSize);
m_arc = new CRioArchive (m_toc, shift, true);
}
public CObject ReadObject (COceanNode node)
{
return m_arc.ReadObject (node);
}
static byte[] ReadIci (IBinaryStream ici, uint key)
{
var rio = new CRioArchive (ici);
var ici_data = rio.ReadEncrypted (key);
return DecryptIci (ici_data);
}
static byte[] DecryptIci (byte[] input)
{
var output = new byte[input.Length];
int src = 0;
int dst = 0;
int tail_size;
int chunk_count = Math.DivRem (input.Length, 6, out tail_size);
for (int n = chunk_count; n > 0; --n)
{
output[dst++] = input[src];
output[dst++] = input[src + chunk_count];
output[dst++] = input[src + chunk_count * 2];
output[dst++] = input[src + chunk_count * 3];
output[dst++] = input[src + chunk_count * 4];
output[dst++] = input[src + chunk_count * 5];
++src;
}
if (tail_size > 0)
Buffer.BlockCopy (input, input.Length - tail_size, output, dst, tail_size);
byte acc = 0;
for (int i = 0; i < output.Length; ++i)
{
output[i] -= acc;
acc += output[i];
output[i] ^= 0xA5;
}
src = 0;
dst = 0;
chunk_count = Math.DivRem (input.Length, 5, out tail_size);
for (int n = chunk_count; n > 0; --n)
{
input[dst++] = output[src];
input[dst++] = output[src + chunk_count];
input[dst++] = output[src + chunk_count * 2];
input[dst++] = output[src + chunk_count * 3];
input[dst++] = output[src + chunk_count * 4];
++src;
}
if (tail_size > 0)
Buffer.BlockCopy (output, output.Length - tail_size, input, dst, tail_size);
acc = 0;
for (int i = input.Length-1; i >= 0; --i)
{
input[i] -= acc;
acc += input[i];
}
src = 0;
dst = 0;
chunk_count = Math.DivRem (input.Length, 3, out tail_size);
for (int n = chunk_count; n > 0; --n)
{
output[dst++] = (byte)(input[src] ^ 0x18);
output[dst++] = (byte)(input[src + chunk_count] ^ 0x3F);
output[dst++] = (byte)(input[src + chunk_count * 2] ^ 0xE2);
++src;
}
if (tail_size > 0)
Buffer.BlockCopy (input, input.Length - tail_size, output, dst, tail_size);
return output;
}
#region IDisposable Members
bool _disposed = false;
public void Dispose ()
{
if (!_disposed)
{
m_input.Dispose();
if (m_toc != m_input)
m_toc.Dispose();
_disposed = true;
}
}
#endregion
}
internal class CRioArchive
{
IBinaryStream m_input;
int m_field_4C;
string m_field_50;
int m_field_54;
bool m_field_60;
int m_shift;
int m_objectSchema = -1;
Dictionary<int, COceanNode> m_OceanMap = new Dictionary<int, COceanNode>();
ArrayList m_LoadArray = new ArrayList();
public IBinaryStream Input { get { return m_input; } }
public ArrayList LoadArray { get { return m_LoadArray; } }
public bool IsEncrypted { get { return 0 != (m_field_4C & 4); } }
private bool m_field_5C { get { return IsEncrypted; } }
public const uint EncryptedSignature = 0x1EDB927C;
public const uint ObjectSignature = 0x29F6CBA4;
public const uint RioSignature = 0x596E32CD;
public const uint IciSignature = 0x673CE92A;
public CRioArchive (IBinaryStream input)
{
m_input = input;
}
public CRioArchive (IBinaryStream input, int shift, bool encrypted) : this (input)
{
m_shift = shift;
if (encrypted)
m_field_4C |= 4;
}
public IBinaryStream SetSource (IBinaryStream source)
{
var prev = m_input;
m_input = source;
return prev;
}
public int GetObjectSchema ()
{
int schema = m_objectSchema;
m_objectSchema = -1;
return schema;
}
public CObject DeserializeRoot ()
{
PopulateLoadArray();
uint signature;
var arc_class = LoadRioTypeCore (out signature);
var obj = CreateObject (arc_class);
MapObjectEntry (obj);
if (RioSignature == signature)
obj.Flags |= 0x80;
else if (EncryptedSignature == signature)
obj.Flags |= 0x180;
DeserializeClassList (obj);
obj.Deserialize (this);
return obj;
}
public CObject ReadObject (COceanNode node)
{
var obj = CreateObject (node.Name);
PopulateLoadArray();
m_input.Position = ((long)node.Offset << m_shift);
int f1 = ReadByte() & 3;
int f2 = ReadByte();
int f3 = ReadByte();
int f4 = 0;
switch (f2 >> 6)
{
case 0: f4 = f3 >> 6; break;
case 1: f4 = f3 >> 2; break;
case 2: f4 = (f3 & 0xFE) << 1 | (ReadByte() & 0xC0) << 1; break;
case 3: f4 = (f3 & 0xFE) << 1 | (ReadByte() & 0xFE) << 6; break;
}
obj.Flags = node.Flags;
MapObjectEntry (obj);
if (2 == f1)
{
int flags = ReadUInt16();
m_field_4C = (m_field_4C & 0xFFFF) | flags << 16;
}
else if (3 == f1)
{
int schema = ReadUInt16();
int flags = ReadUInt16();
m_field_4C = (m_field_4C & 0xFFFF) | flags << 16;
}
obj.Deserialize (this);
return obj;
}
CObject CreateObject (string class_name)
{
if (!s_classTable.ContainsKey (class_name))
throw new InvalidFormatException (string.Format ("[RIO] Unknown class '{0}'", class_name));
return s_classTable[class_name].CreateObject();
}
void PopulateLoadArray ()
{
m_LoadArray.Clear();
m_LoadArray.Add (null);
m_LoadArray.Add (this);
}
static readonly ISet<uint> CoreSignatures = new HashSet<uint> {
IciSignature, EncryptedSignature, RioSignature, ObjectSignature
};
public string LoadRioTypeCore (out uint signature)
{
signature = m_input.ReadUInt32();
if (!CoreSignatures.Contains (signature))
throw new InvalidFormatException ("[RIO] invalid signature");
int version = ReadUInt16();
if (version < 0x10 || version > 0x3FFF)
throw new InvalidFormatException ("[RIO] invalid version");
if (version >= 0x11)
{
m_field_4C &= 0xFFFF;
m_field_4C |= ReadUInt16() << 16;
}
if (EncryptedSignature == signature)
m_field_4C |= 0xC;
return ReadClass();
}
int m_depth = 0;
const int MaxRecursionDepth = 40; // arbitrary
void DeserializeClassList (CObject root)
{
if (IsEncrypted && 0 != (root.Flags & 0x200))
return;
try
{
if (++m_depth > MaxRecursionDepth)
throw new InvalidFormatException ("[RIO] deserialization recursion limit exceeded");
int count = ReadCount();
for (int i = 0; i < count; ++i)
{
if (IsEncrypted)
{
var node = CreateOceanEntry1 ("unrefix");
DeserializeNode (node, node != null);
if (node != null)
node.Parent = root;
}
else
{
m_field_50 = ReadString();
m_field_54 = 0;
var node = CreateOceanEntry2 (m_field_50);
if (node != null)
{
MapObjectEntry (node);
DeserializeNode (node);
node.Parent = root;
}
else
{
node = FindObject (m_field_50) as COceanNode;
MapObjectEntry (node);
DeserializeNode (node, false);
}
}
}
}
finally
{
--m_depth;
}
}
void DeserializeNode (COceanNode node, bool store_to_map = true)
{
int flags = ReadUInt16(); // this.field_1E
string class_ref;
switch (flags & 7)
{
case 0:
if (0 != (flags & 0x8000))
ReadByte();
else
ReadUInt16();
class_ref = ReadClass();
break;
case 1:
ReadInt32();
class_ref = ReadCType();
break;
default:
throw new InvalidFormatException();
}
node.ClassName = class_ref;
if (node != null)
{
if (store_to_map)
node.Flags = flags;
if (0 != (flags & 8))
{
if (!store_to_map)
node.Flags |= 8;
int id1 = ReadInt32(); // this.field_20
int id2 = ReadInt32(); // this.field_24
if (IsEncrypted && store_to_map)
{
node.Flags |= 0x100;
if (!m_OceanMap.ContainsKey (id1))
m_OceanMap[id1] = node;
}
if (node != null)
{
node.Offset = (uint)id1;
node.Size = (uint)id2;
}
}
}
else
{
if (0 == (flags & 8))
throw new InvalidFormatException();
int id = ReadInt32();
ReadInt32();
if (!m_OceanMap.TryGetValue (id, out node))
throw new InvalidFormatException();
}
DeserializeClassList (node);
}
string ReadCType ()
{
int c = ReadUInt16();
switch (c)
{
case 0x1E57:
return ReadClass();
case 0x2D6B:
return ReadBasicType();
case 0x2F1A:
return ReadBasicType();
case 0x369E:
if (m_field_54 > 0x13)
return ReadMsgClass();
else
return ReadMessage();
default:
throw new InvalidFormatException();
}
}
string ReadMessage ()
{
int id = ReadUInt16();
int cLen = ReadUInt16();
if (id != -1 || cLen >= 0x400)
throw new InvalidFormatException();
var buffer = new byte[cLen];
if (cLen != Read (buffer, 0, cLen))
return null;
var name = Encodings.cp932.GetString (buffer, 2, cLen-2);
return GetRtcFromMessageName (name);
}
string ReadBasicType ()
{
ReadUInt16();
int cLen = ReadUInt16();
if (cLen >= 0x40 || cLen != Read (m_name_buf, 0, cLen))
throw new InvalidFormatException();
var name = Encodings.cp932.GetString (m_name_buf, 0, cLen);
if (!s_basicTypeList.ContainsKey (name))
throw new InvalidFormatException (string.Format ("[RIO] Unknown basic type '{0}'", name));
return s_basicTypeList[name];
}
string ReadMsgClass ()
{
int wTag = ReadUInt16();
int obTag;
if (0x7FFF == wTag)
obTag = ReadInt32();
else
obTag = ((wTag & wClassTag) << 16) | (wTag & ~wClassTag);
if (0 == (obTag & dwBigClassTag))
throw new InvalidFormatException ("[RIO] invalid message class");
if (0xFFFF == wTag)
{
throw new NotImplementedException();
}
else
{
throw new NotImplementedException();
}
}
string GetRtcFromMessageName (string name)
{
throw new NotImplementedException();
}
void MapObjectEntry (CObject node) // CArchive::MapObject
{
m_LoadArray.Add (node);
}
CObject FindObject (string name)
{
throw new NotImplementedException();
}
COceanNode CreateOceanEntry1 (string name)
{
return new COceanNode (name);
}
COceanNode CreateOceanEntry2 (string name)
{
return new COceanNode (name);
}
COceanNode CreateAnonymousRio (string name)
{
throw new NotImplementedException();
}
const int wClassTag = 0x8000; // 0x8000 indicates class tag (OR'd)
const int dwBigClassTag = (int)-0x80000000; // 0x8000000 indicates big class tag (OR'd)
public CObject ReadRioReference (string base_ref)
{
if (!m_field_60)
{
m_field_60 = true;
if (m_field_5C)
{
int count = ReadShortCount();
for (int i = 0; i < count; ++i)
MapObjectEntry (null); // new CObject()
}
}
int tag;
var class_ref = ReadClass (out tag);
if (null == class_ref)
{
if (tag >= m_LoadArray.Count)
throw new InvalidFormatException ("Bad class");
return m_LoadArray[tag] as CObject;
}
COceanNode obj;
int flags = ReadUInt16();
if (0 != (flags & 0x40))
{
obj = CreateAnonymousRio (class_ref);
MapObjectEntry (obj);
return obj;
}
int id1 = 0, id2 = 0;
string name = null;
if (IsEncrypted)
{
id1 = ReadInt32();
id2 = ReadInt32();
}
else
{
name = ReadString();
}
var rio = ReadRioReference ("CRio");
if (null == rio)
throw new InvalidFormatException();
if (0 != (flags & 7))
ReadInt32();
else if (0 != (flags & 0x8000))
ReadByte();
else
ReadUInt16();
if (IsEncrypted)
{
obj = ReadEncryptedObject (rio, class_ref, flags, id1, id2);
obj.Name = base_ref;
}
else
{
throw new NotImplementedException();
}
MapObjectEntry (obj);
return obj;
}
string ReadClass ()
{
int tag;
return ReadClass (out tag);
}
string ReadClass (out int obTag)
{
int wTag = ReadUInt16();
if (0x7FFF == wTag)
{
obTag = ReadInt32();
}
else
{
obTag = ((wTag & wClassTag) << 16) | (wTag & ~wClassTag);
}
if (0 == (obTag & dwBigClassTag))
{
return null;
}
string class_ref;
if (0xFFFF == wTag)
{
uint schema = 0;
if ((m_field_4C & 8) != 0)
class_ref = LoadScrambledClass (out schema);
else
class_ref = LoadRuntimeClass (out schema);
if (null == class_ref)
throw new InvalidFormatException();
// m_objectSchema = (int)schema;
m_LoadArray.Add (class_ref);
}
else
{
obTag &= 0x7FFFFFFF;
if (0 == obTag || obTag >= m_LoadArray.Count)
throw new InvalidFormatException ("Bad class");
class_ref = (string)m_LoadArray[obTag];
}
return class_ref;
}
byte[] m_name_buf = new byte[0x100];
// loads a runtime class description
string LoadRuntimeClass (out uint schema)
{
schema = ReadUInt16();
int nLen = ReadUInt16();
// load the class name
if (nLen >= 0x40 || Read (m_name_buf, 0, nLen) != nLen)
return null;
return Encoding.ASCII.GetString (m_name_buf, 0, nLen);
}
string LoadScrambledClass (out uint schema)
{
schema = ReadUInt16();
int length = ReadByte();
if (0xFF == length)
{
length = ReadUInt16();
}
if (length >= 0x100 || Read (m_name_buf, 0, length) != length)
return null;
return DecodeClassName (m_name_buf, length);
}
COceanNode ReadEncryptedObject (CObject rio, string class_ref, int flags, int id1, int id2)
{
COceanNode node;
if (!m_OceanMap.TryGetValue (id1, out node))
throw new InvalidFormatException();
if (node != null)
{
node.Offset = DecodeOffset (id1);
node.Size = DecodeSize (id2);
}
return node;
}
public int ReadInt32 ()
{
return m_input.ReadInt32();
}
public long ReadInt64 ()
{
return m_input.ReadInt64();
}
public ushort ReadUInt16 ()
{
return m_input.ReadUInt16();
}
public byte ReadByte ()
{
return m_input.ReadUInt8();
}
public int Read (byte[] buffer, int offset, int count)
{
return m_input.Read (buffer, offset, count);
}
public byte[] ReadBytes (int count)
{
return m_input.ReadBytes (count);
}
public bool ReadBool ()
{
return m_input.ReadUInt8() != 0;
}
public string ReadString ()
{
int nLength = ReadStringLength();
if (0 == nLength)
return "";
if (nLength < 0)
throw new InvalidFormatException();
var buffer = m_input.ReadBytes (nLength);
if (buffer.Length != nLength)
throw new EndOfStreamException();
return Encodings.cp932.GetString (buffer);
}
public int ReadCount ()
{
int count = ReadUInt16();
if (count != 0xFFFF)
return count;
return ReadInt32();
}
public int ReadShortCount ()
{
int count = ReadByte();
if (count != 0xFF)
return count;
return ReadUInt16();
}
int ReadStringLength ()
{
// First, try to read a one-byte length
int length = ReadByte();
if (length < 0xFF)
return length;
// Try a two-byte length
length = ReadUInt16();
if (0xFFFE == length)
throw new NotSupportedException ("[RIO] Unicode strings not supported");
if (length < 0xFFFF)
return length;
// 4-byte length
return ReadInt32();
}
public byte[] ReadEncrypted (uint key)
{
uint size1 = m_input.ReadUInt32() ^ 0xC92E568B;
uint size2 = m_input.ReadUInt32() ^ 0xC92E568F;
size2 >>= 3;
size1 = ~size1;
if (size1 != size2)
throw new InvalidFormatException ("Invalid encrypted chunk");
var ici_data = new byte[size1];
int dst = 0;
while (dst < ici_data.Length)
{
ushort checksum = 0;
int portion = Math.Min (0x20, ici_data.Length - dst);
portion = m_input.Read (ici_data, dst, portion);
for (int i = portion; i > 0; --i)
{
byte b = (byte)(ici_data[dst] ^ key);
ici_data[dst++] = b;
checksum += (ushort)(b * i);
uint bit = key;
bit = (bit >> 15) & 1;
key = ~(bit + key*2 + 0xA3B376C9u);
}
if (portion < 0x20)
break;
ushort chunk_sum = m_input.ReadUInt16();
if (chunk_sum != checksum)
throw new InvalidFormatException ("Encrypted chunk checksum mismatch");
}
return ici_data;
}
static uint DecodeOffset (int offset)
{
return (uint)offset - 0xA2FB6AD1;
}
static uint DecodeSize (int size)
{
uint a = (uint)size - 0xE7B5D9F8;
uint b = a >> 13;
return (a - (b & 0xFFF)) << 19 | b;
}
static string DecodeClassName (byte[] enc, int length)
{
using (var output = new MemoryStream())
using (var input = new MemoryStream (enc, 0, length))
using (var bits = new LsbBitStream (input))
{
if (0 == bits.GetNextBit())
output.WriteByte ((byte)'C');
for (;;)
{
int b = bits.GetNextBit();
if (-1 == b)
break;
int c;
if (0 == b)
{
int idx = bits.GetBits (4);
if (-1 == idx)
break;
c = CharMap1[idx];
}
else if (bits.GetNextBit() != 0)
{
int idx = bits.GetBits (5);
if (-1 == idx)
break;
c = CharMap3[idx];
}
else
{
int idx = bits.GetBits (4);
if (-1 == idx)
break;
if (idx != 0)
{
c = CharMap2[idx];
}
else
{
c = bits.GetBits (8);
if (-1 == c)
break;
}
}
output.WriteByte ((byte)c);
}
var buf = output.GetBuffer();
return Encodings.cp932.GetString (buf, 0, (int)output.Length);
}
}
static readonly char[] CharMap1 = {
'e', 'a', 'i', 't', 'r', 'o', 's', 'd', 'u', 'c', 'm', 'n', 'S', 'g', 'l', 'R' };
static readonly char[] CharMap2 = {
'\x1', 'C', 'O', 'F', 'L', 'f', 'B', 'M', 'x', 'p', 'h', 'y', 'A', 'V', 'b', 'I' };
static readonly char[] CharMap3 = {
'E', 'H', 'T', 'D', 'P', 'W', 'X', 'k', 'q', 'v', 'N', 'j', 'w', 'G', 'z', '0',
'2', 'U', '_', 'K', '1', '5', 'J', 'Q', 'Z', '4', '6', '7', '8', '3', '9', '\x0' };
static readonly Dictionary<string, string> s_basicTypeList = new Dictionary<string, string>
{
{ "バイト", "byte" },
{ "短正整数", "short" },
{ "短整数", "ushort" },
{ "正整数", "int" },
{ "整数", "uint" },
{ "色", "Color" },
};
static readonly Dictionary<string, IObjectFactory> s_classTable = new Dictionary<string, IObjectFactory>
{
{ "CObjectArcMan", new CObjectFactory<CObjectArcMan>() },
{ "CrelicUnitedGameProject", new CObjectFactory<CrelicUnitedGameProject>() },
{ "CStdb", new CObjectFactory<CStdb>() },
};
}
internal abstract class CObject
{
public int Flags;
public string ClassName;
public abstract void Deserialize (CRioArchive arc);
}
internal class CStringArray : CObject, IReadOnlyList<string>
{
string[] m_data = new string[0];
public int Count { get { return m_data.Length; } }
public string this[int index]
{
get { return m_data[index]; }
set { m_data[index] = value; }
}
public void SetSize (int count)
{
Array.Resize (ref m_data, count);
}
public override void Deserialize (CRioArchive arc)
{
int count = arc.ReadCount();
SetSize (count);
for (int i = 0; i < count; ++i)
m_data[i] = arc.ReadString();
}
public IEnumerator<string> GetEnumerator ()
{
foreach (var s in m_data)
yield return s;
}
IEnumerator IEnumerable.GetEnumerator ()
{
return m_data.GetEnumerator();
}
}
internal class CPtrArray<CType> : CObject, IReadOnlyList<CType> where CType : CObject, new()
{
public CType[] m_data = new CType[0];
public int Count { get { return m_data.Length; } }
public CType this[int index]
{
get { return m_data[index]; }
set { m_data[index] = value; }
}
public void SetSize (int count)
{
Array.Resize (ref m_data, count);
}
public override void Deserialize (CRioArchive arc)
{
int count = arc.ReadCount();
SetSize (count);
for (int i = 0; i < count; ++i)
{
if (arc.ReadBool())
{
var obj = new CType();
m_data[i] = obj;
obj.Deserialize (arc);
}
}
}
public IEnumerator<CType> GetEnumerator ()
{
foreach (var item in m_data)
yield return item;
}
IEnumerator IEnumerable.GetEnumerator ()
{
return m_data.GetEnumerator ();
}
}
internal class CInstallSource : CObject
{
public ushort Version;
public int field_14;
public int field_18;
public string RioName; // rio filename [dst]
public long RioOffset; // rio offset
public long RioSize; // rio size
public int field_A8;
public int field_B0;
public byte[] field_D4;
public override void Deserialize (CRioArchive arc)
{
Version = arc.ReadUInt16();
if (Version >= 7)
{
field_14 = arc.ReadInt32();
field_18 = arc.ReadInt32();
arc.ReadByte();
arc.ReadString();
}
arc.ReadString(); // registry branch
arc.ReadString(); // disk name
arc.ReadString(); // rio filename [src]
arc.ReadString();
arc.ReadString();
arc.ReadInt64(); // rio offset [=0]
arc.ReadInt64(); // rio size
if (Version < 6)
{
arc.ReadInt32();
arc.ReadInt32();
}
else
{
arc.ReadInt32();
}
RioName = arc.ReadString();
RioOffset = arc.ReadInt64();
RioSize = arc.ReadInt64();
if (Version < 6)
{
arc.ReadInt64();
}
arc.ReadInt32();
arc.ReadString();
arc.ReadInt32();
arc.ReadInt32();
arc.ReadInt32();
arc.ReadInt32();
arc.ReadInt32();
arc.ReadString();
int count = arc.ReadCount();
arc.ReadBytes (count*4);
PrepareBuffer(); // sub_10011700 (this);
arc.Read (field_D4, 0, field_D4.Length);
}
void PrepareBuffer ()
{
field_B0 = (int)((RioSize + 0xFFFF) >> 16);
field_A8 = 16;
int length = (field_B0 + 7) >> 3;
field_D4 = new byte[length];
}
}
internal class CObjectArcMan : CObject
{
public int Version;
public string Title;
public CPtrArray<CInstallSource> ArcList = new CPtrArray<CInstallSource>();
public int field_14 = 0x1873BE26;
public int field_1C;
public int field_20;
public int TocOffset; // RioTocOffset
public int TocSize; // RioTocSize
public int field_38 = 0x14;
public string RioFileName;
public CStringArray field_80 = new CStringArray();
public int field_98 = 0x30;
public override void Deserialize (CRioArchive arc)
{
Version = arc.ReadInt32();
field_14 = arc.ReadInt32();
arc.ReadByte();
arc.ReadByte();
if (Version < 10)
{
field_1C = 0;
field_20 = 0;
}
else
{
field_1C = arc.ReadInt32();
field_20 = arc.ReadInt32();
}
arc.ReadInt32();
arc.ReadInt32();
arc.ReadInt32();
if (Version >= 6)
{
TocOffset = arc.ReadInt32();
TocSize = arc.ReadInt32();
arc.ReadInt32();
}
if (Version >= 8)
field_38 = arc.ReadInt32();
Title = arc.ReadString();
arc.ReadInt32();
arc.ReadString();
arc.ReadInt32();
arc.ReadString();
arc.ReadString(); // registry branch
arc.ReadString();
arc.ReadInt32();
arc.ReadString();
field_80.Deserialize (arc);
arc.ReadInt32();
if (Version >= 9)
RioFileName = arc.ReadString();
if (Version >= 7)
arc.ReadString(); // InstallManual
if (Version >= 5)
field_98 = arc.ReadInt32();
ArcList.Deserialize (arc); // CPtrArray::Serialize
for (int i = 0; i < ArcList.Count; ++i)
{
var entry = ArcList[i];
if (entry != null)
{
entry.field_14 = field_1C;
entry.field_18 = field_20;
}
}
}
}
internal class CrelicUnitedGameProject : CObject
{
public int Version;
public CObject field_08;
public CObject field_0C;
public CObject field_10;
public CObject field_14;
public CObject field_18;
public CObject field_1C;
public CObject field_24;
public CObject field_28;
public CObject field_2C;
public CObject field_30;
public CUnknown1 field_34 = new CUnknown1();
public CObject field_38;
internal const uint RioKey = 0x7E6B8CE2;
public override void Deserialize (CRioArchive arc)
{
if (arc.IsEncrypted)
{
var data = arc.ReadEncrypted (RioKey);
using (var input = new BinMemoryStream (data))
{
var prev_source = arc.SetSource (input);
try
{
ReadRelic (arc);
}
finally
{
arc.SetSource (prev_source);
}
}
}
else
ReadRelic (arc);
}
void ReadRelic (CRioArchive arc)
{
Version = arc.ReadInt32();
if (Version >= 0x24)
{
field_24 = arc.ReadRioReference ("CDatabaseBase"); // UnivUI
field_28 = arc.ReadRioReference ("CDatabaseBase");
field_10 = arc.ReadRioReference ("CBoxOcean"); // rvmm
field_14 = arc.ReadRioReference ("CObjectOcean"); // UnivUI
field_18 = arc.ReadRioReference ("CObjectOcean"); // UnivUI
field_0C = arc.ReadRioReference ("CProcessOcean"); // Vm60
if (Version >= 0x25)
field_30 = arc.ReadRioReference ("CStdb"); // UnivUI
if (Version >= 0x26)
field_2C = arc.ReadRioReference ("CRio"); // UnivUI
if (Version >= 0x27)
field_1C = arc.ReadRioReference ("CRio");
if (Version >= 0x29)
field_38 = arc.ReadRioReference ("CRio");
field_34.Deserialize (arc);
if (Version >= 0x28)
field_08 = arc.ReadRioReference ("CRio");
}
else if (Version >= 0x20)
{
field_0C = arc.ReadRioReference ("CProcessOcean");
field_10 = arc.ReadRioReference ("CBoxOcean");
field_14 = arc.ReadRioReference ("CObjectOcean");
field_18 = arc.ReadRioReference ("CObjectOcean");
field_1C = arc.ReadRioReference ("CSoundManEx");
if (Version >= 0x23)
field_24 = arc.ReadRioReference ("CDatabaseBase");
if (Version >= 0x22)
field_28 = arc.ReadRioReference ("CDatabaseBase");
if (Version >= 0x21)
field_34.Deserialize (arc);
}
else
throw new NotSupportedException (string.Format ("rUGP schema {0} not supported", Version));
}
}
internal class CUnknown1 : CObject
{
public int Version = 0;
public string field_04; // registry branch
public string field_08; // version
public string field_0C;
public string field_14;
public int field_18 = 1000;
public string field_1C; // copyright
public string field_10;
public int field_20 = 1;
public int field_24 = 1;
public byte[] field_28;
public int field_38;
public string field_3C;
public string field_40;
public string field_44;
public string field_48;
public string field_4C;
public string field_50;
public override void Deserialize (CRioArchive arc)
{
Version = arc.ReadInt32();
if (Version >= 2)
field_04 = arc.ReadString();
field_08 = arc.ReadString();
field_0C = arc.ReadString();
field_14 = arc.ReadString();
field_1C = arc.ReadString();
field_18 = arc.ReadInt32();
if (0 == Version)
return;
if (Version >= 2)
{
field_28 = arc.ReadBytes (16);
field_38 = arc.ReadInt32();
}
field_3C = arc.ReadString();
field_40 = arc.ReadString();
if (Version >= 3)
field_44 = arc.ReadString();
if (Version >= 4)
{
field_10 = arc.ReadString();
field_20 = arc.ReadInt32();
}
if (Version >= 5)
{
field_24 = arc.ReadInt32();
}
else
{
if (field_28.ToUInt16 (0) < 0x7D3)
field_24 = 2;
else
field_24 = 1;
}
if (Version >= 6)
{
field_48 = arc.ReadString();
field_4C = arc.ReadString();
field_50 = arc.ReadString();
}
}
}
internal class CStdb : CObject
{
public string field_0C;
public override void Deserialize (CRioArchive arc)
{
field_0C = arc.ReadString();
}
}
internal class CBoxOcean : CObject
{
public CObject field_10;
public override void Deserialize (CRioArchive arc)
{
field_10 = arc.ReadRioReference ("CFrameBuffer");
}
}
internal class COceanNode : CObject
{
public string Name;
public CObject Parent;
public uint Offset;
public uint Size;
public COceanNode (string name)
{
Name = name;
}
public override void Deserialize (CRioArchive arc)
{
throw new NotImplementedException ("COceanNode.Deserialize not impelemented");
}
}
internal interface IObjectFactory
{
CObject CreateObject ();
}
internal class CObjectFactory<CType> : IObjectFactory where CType : CObject, new()
{
public CObject CreateObject ()
{
return new CType();
}
}
}
Reference in New Issue Copy Permalink