public static Palette256 FromArchive(string file, bool ignoreCase, DATArchive archive)
{
if (!archive.Contains(file, ignoreCase))
{
return((Palette256)null);
}
return(Palette256.FromRawData(archive.ExtractFile(file, ignoreCase)));
}
public static PaletteTable FromArchive(string pattern, DATArchive archive)
{
PaletteTable table = new PaletteTable();
table.LoadTables(pattern, archive);
table.LoadPalettes(pattern, archive);
return(table);
}
public static EPFImage FromArchive(string file, bool ignoreCase, DATArchive archive)
{
if (!archive.Contains(file, ignoreCase))
{
return((EPFImage)null);
}
return(EPFImage.FromRawData(archive.ExtractFile(file, ignoreCase), file));
}
public KhanArchive(string path, bool male)
{
string str = male ? "m" : "w";
this.AD = DATArchive.FromFile(path + "\\khan" + str + "ad.dat");
this.EH = DATArchive.FromFile(path + "\\khan" + str + "eh.dat");
this.IM = DATArchive.FromFile(path + "\\khan" + str + "im.dat");
this.NS = DATArchive.FromFile(path + "\\khan" + str + "ns.dat");
this.TZ = DATArchive.FromFile(path + "\\khan" + str + "tz.dat");
}
/// <summary>
/// Loads a palette file from an archive (case-sensitive).
/// </summary>
/// <param name="file">Palette file to load.</param>
/// <param name="archive">Data archive to load from.</param>
/// <returns>256 color palette.</returns>
public static Palette256 FromArchive(string file, DATArchive archive)
{
// Check if File Exists
if (!archive.Contains(file))
{
return(null);
}
// Extract and Create File
return(FromRawData(archive.ExtractFile(file)));
}
/// <summary>
/// Loads an EPF image file from an archive.
/// </summary>
/// <param name="file">EPF image to load.</param>
/// <param name="ignoreCase">Ignore case (noncase-sensitive).</param>
/// <param name="archive">Data archive to load from.</param>
/// <returns>EPF image.</returns>
public static EPFImage FromArchive(string file, bool ignoreCase, DATArchive archive)
{
// Check if File Exists
if (!archive.Contains(file, ignoreCase))
{
return(null);
}
// Extract and Create File
return(FromRawData(archive.ExtractFile(file, ignoreCase)));
}
public int LoadPalettes(string pattern, DATArchive archive)
{
this.palettes.Clear();
foreach (DATFileEntry file in archive.Files)
{
if (file.Name.ToUpper().EndsWith(".PAL") && file.Name.ToUpper().StartsWith(pattern.ToUpper()))
{
this.palettes.Add(Convert.ToInt32(Path.GetFileNameWithoutExtension(file.Name).Remove(0, pattern.Length)), Palette256.FromArchive(file.Name, archive));
}
}
return(this.palettes.Count);
}
public int LoadTables(string pattern, DATArchive archive)
{
this.entries.Clear();
foreach (DATFileEntry file in archive.Files)
{
if (file.Name.ToUpper().EndsWith(".TBL") && file.Name.ToUpper().StartsWith(pattern.ToUpper()))
{
string s = Path.GetFileNameWithoutExtension(file.Name).Remove(0, pattern.Length);
if (s != "ani")
{
StreamReader streamReader = new StreamReader((Stream) new MemoryStream(archive.ExtractFile(file)));
while (!streamReader.EndOfStream)
{
string[] strArray = streamReader.ReadLine().Split(' ');
if (strArray.Length == 3)
{
int int32_1 = Convert.ToInt32(strArray[0]);
int int32_2 = Convert.ToInt32(strArray[1]);
int int32_3 = Convert.ToInt32(strArray[2]);
int result = 0;
if (int.TryParse(s, out result))
{
this.overrides.Add(new PaletteTableEntry(int32_1, int32_2, int32_3));
}
else
{
this.entries.Add(new PaletteTableEntry(int32_1, int32_2, int32_3));
}
}
else if (strArray.Length == 2)
{
int int32_1 = Convert.ToInt32(strArray[0]);
int max = int32_1;
int int32_2 = Convert.ToInt32(strArray[1]);
int result = 0;
if (int.TryParse(s, out result))
{
this.overrides.Add(new PaletteTableEntry(int32_1, max, int32_2));
}
else
{
this.entries.Add(new PaletteTableEntry(int32_1, max, int32_2));
}
}
}
streamReader.Close();
}
}
}
return(this.entries.Count);
}
/// <summary>
/// Loads a tileset from an archive.
/// </summary>
/// <param name="file">Tileset to load.</param>
/// <param name="ignoreCase">Ignore case (noncase-sensitive).</param>
/// <param name="archive">Data archive to load from.</param>
/// <returns>Number of tiles loaded.</returns>
public static Tileset FromArchive(string file, bool ignoreCase, DATArchive archive)
{
// Check if File Exists
if (!archive.Contains(file, ignoreCase))
{
return(null);
}
// Extract and Create File
Tileset tileset = LoadTiles(new MemoryStream(archive.ExtractFile(file, ignoreCase)));
tileset.name = Path.GetFileNameWithoutExtension(file).ToUpper();
tileset.filename = file;
// Return Tileset
return(tileset);
}
public static EPFImage FromArchive(string fileName, bool ignoreCase, DATArchive archive)
{
int index1 = archive.IndexOf(fileName, true);
if (index1 == -1)
{
return((EPFImage)null);
}
using (FileStream fileStream = File.Open(archive.FileName, FileMode.Open, FileAccess.Read, FileShare.Read))
{
using (BinaryReader binaryReader = new BinaryReader((Stream)fileStream))
{
EPFImage epfImage = new EPFImage();
epfImage.Name = Path.GetFileName(fileName).ToLower();
fileStream.Seek(archive.Files[index1].StartAddress, SeekOrigin.Begin);
epfImage.expectedFrames = (int)binaryReader.ReadUInt16();
epfImage.width = (int)binaryReader.ReadUInt16();
epfImage.height = (int)binaryReader.ReadUInt16();
epfImage.unknown = (int)binaryReader.ReadUInt16();
epfImage.tocAddress = (long)(binaryReader.ReadUInt32() + 12U);
if (epfImage.ExpectedFrames <= 0)
{
return((EPFImage)null);
}
epfImage.frames = new EPFFrame[epfImage.ExpectedFrames];
for (int index2 = 0; index2 < epfImage.ExpectedFrames; ++index2)
{
binaryReader.BaseStream.Seek(archive.Files[index1].StartAddress + epfImage.TOCAddress + (long)(index2 * 16), SeekOrigin.Begin);
int top = (int)binaryReader.ReadUInt16();
int left = (int)binaryReader.ReadUInt16();
int num1 = (int)binaryReader.ReadUInt16();
int width = (int)binaryReader.ReadUInt16() - left;
int height = num1 - top;
uint num2 = binaryReader.ReadUInt32() + 12U;
uint num3 = binaryReader.ReadUInt32() + 12U;
binaryReader.BaseStream.Seek(archive.Files[index1].StartAddress + (long)num2, SeekOrigin.Begin);
byte[] rawData = (long)(num3 - num2) == (long)(width * height) ? binaryReader.ReadBytes((int)num3 - (int)num2) : binaryReader.ReadBytes((int)(epfImage.TOCAddress - (long)num2));
epfImage.Frames[index2] = new EPFFrame(left, top, width, height, rawData);
}
return(epfImage);
}
}
}
private void Form1_Shown(object sender, EventArgs e)
{
foreach (DATFileEntry file in DATArchive.FromFile(filename).Files)
{
Match match = new Regex("(item)(\\d+)(\\.epf)", RegexOptions.IgnoreCase | RegexOptions.Singleline).Match(file.Name);
if (match.Success)
{
int num = int.Parse(match.Groups[2].ToString());
if (num < this.minimum)
{
this.minimum = num;
}
if (num > this.maximum)
{
this.maximum = num;
}
}
}
DisplayItems(this.minimum);
}
/// <summary>
/// Loads the default palettes from the specified archive.
/// </summary>
/// <param name="pattern">Pattern to check for (prefix string).</param>
/// <param name="archive">Data archive.</param>
/// <returns>Number of palettes loaded.</returns>
public int LoadPalettes(string pattern, DATArchive archive)
{
palettes.Clear();
foreach (DATFileEntry file in archive.Files)
{
// Check for Palette
if (file.Name.ToUpper().EndsWith(".PAL") && file.Name.ToUpper().StartsWith(pattern.ToUpper()))
{
// Get Index
int index = Convert.ToInt32(
Path.GetFileNameWithoutExtension(file.Name).Remove(0, pattern.Length));
// Get File from Archive
Palette256 palette = Palette256.FromArchive(file.Name, archive);
// Add Palette
palettes.Add(index, palette);
}
}
return(palettes.Count);
}
private void DisplayItems(int number)
{
DATArchive archive = DATArchive.FromFile(filename);
PaletteTable paletteTable = new PaletteTable("item", archive);
foreach (DATFileEntry file in archive.Files)
{
Match match = new Regex("(item)(\\d+)(\\.epf)", RegexOptions.IgnoreCase | RegexOptions.Singleline).Match(file.Name);
if (match.Success)
{
EPFImage epfImage = EPFImage.FromArchive(file.Name, archive);
int num1 = int.Parse(match.Groups[2].ToString());
if (num1 == number)
{
panelItemFill.Controls.Clear();
for (int index = 0; index < epfImage.Frames.Length; ++index)
{
int num2 = (num1 - 1) * 266 + (index + 1);
PictureBox pictureBox = new PictureBox();
pictureBox.Name = string.Format("Sprite ID: {0} ({1} for Npc)", (object)num2, (object)(num2 + 16384));
pictureBox.Image = (Image)DAGraphics.RenderImage(epfImage.Frames[index], paletteTable[num1 * 266]);
pictureBox.Click += (EventHandler)((o, ea) =>
{
txtSprite.Text = (o as PictureBox).Name;
});
pictureBox.BorderStyle = BorderStyle.FixedSingle;
if (pictureBox.Image.Width > 1 || pictureBox.Image.Height > 1)
{
panelItemFill.Controls.Add((Control)pictureBox);
}
}
break;
}
}
}
current = number;
buttonLeft.Enabled = this.current > this.minimum;
buttonRight.Enabled = this.current < this.maximum;
}
public void DisplayItem(int SpriteID)
{
DATArchive archive = DATArchive.FromFile(filename);
PaletteTable paletteTable = new PaletteTable("item", archive);
foreach (DATFileEntry file in archive.Files)
{
Match match = new Regex("(item)(\\d+)(\\.epf)", RegexOptions.IgnoreCase | RegexOptions.Singleline).Match(file.Name);
if (match.Success)
{
EPFImage epfImage = EPFImage.FromArchive(file.Name, archive);
int num1 = int.Parse(match.Groups[2].ToString());
for (int index = 0; index < epfImage.Frames.Length; ++index)
{
int num2 = (num1 - 1) * 266 + (index + 1);
if (num2 == SpriteID)
{
Bitmap bmp = new Bitmap(DAGraphics.RenderImage(epfImage.Frames[index], paletteTable[num1 * 266]));
picSelectedItem.Image = bmp;
}
}
}
}
}
/// <summary>
/// Loads the default tables from the specified archive.
/// </summary>
/// <param name="pattern">Pattern to check for (prefix string).</param>
/// <param name="archive">Data archive.</param>
/// <returns>Number of table entries loaded.</returns>
public int LoadTables(string pattern, DATArchive archive)
{
entries.Clear();
foreach (DATFileEntry file in archive.Files)
{
// Check for Palette
if (file.Name.ToUpper().EndsWith(".TBL") && file.Name.ToUpper().StartsWith(pattern.ToUpper()))
{
// Get Index
string tableName =
Path.GetFileNameWithoutExtension(file.Name).Remove(0, pattern.Length);
if (tableName != "ani")
{
// Get Stream and Reader for Data
MemoryStream stream = new MemoryStream(archive.ExtractFile(file));
StreamReader reader = new StreamReader(stream);
#region Read Lines and Parse Values
while (!reader.EndOfStream)
{
string line = reader.ReadLine();
string[] lineSplit = line.Split(' ');
if (lineSplit.Length == 3)
{
int min = Convert.ToInt32(lineSplit[0]);
int max = Convert.ToInt32(lineSplit[1]);
int pal = Convert.ToInt32(lineSplit[2]);
int index = 0;
if (int.TryParse(tableName, out index))
{
overrides.Add(new PaletteTableEntry(min, max, pal));
}
else
{
entries.Add(new PaletteTableEntry(min, max, pal));
}
}
else if (lineSplit.Length == 2)
{
int min = Convert.ToInt32(lineSplit[0]);
int max = min;
int pal = Convert.ToInt32(lineSplit[1]);
int index = 0;
if (int.TryParse(tableName, out index))
{
overrides.Add(new PaletteTableEntry(min, max, pal));
}
else
{
entries.Add(new PaletteTableEntry(min, max, pal));
}
}
}
reader.Close();
#endregion
}
}
}
return(entries.Count);
}
public PaletteTable(string pattern, DATArchive archive)
{
this.LoadTables(pattern, archive);
this.LoadPalettes(pattern, archive);
}
public static SPFImage FromArchive(string file, DATArchive archive)
{
if (!archive.Contains(file))
{
return(null);
}
var stream = new MemoryStream(archive.ExtractFile(file));
var reader = new BinaryReader(stream);
var spf = new SPFImage();
int unknown1 = reader.ReadInt32();
int unknown2 = reader.ReadInt32();
spf.colorFormat = reader.ReadInt32();
if (spf.colorFormat == 0)
{
var palette = new Palette256();
byte[] alpha = reader.ReadBytes(512);
byte[] color = reader.ReadBytes(512);
for (int i = 0; i < 256; ++i)
{
ushort val = BitConverter.ToUInt16(color, i * 2);
int b = 8 * ((int)val % 32);
int g = 8 * ((int)val / 32 % 32);
int r = 8 * ((int)val / 32 / 32 % 32);
palette[i] = Color.FromArgb(r, g, b);
}
spf.palette = palette;
}
spf.expectedFrames = reader.ReadInt32();
spf.frames = new SPFFrame[spf.expectedFrames];
for (int i = 0; i < spf.expectedFrames; ++i)
{
int left = reader.ReadInt16();
int top = reader.ReadInt16();
int width = reader.ReadInt16();
int height = reader.ReadInt16();
int unknown3 = reader.ReadInt32();
int unknown4 = reader.ReadInt32();
int startAddress = reader.ReadInt32();
int byteWidth = reader.ReadInt32();
int length = reader.ReadInt32();
int semiLength = reader.ReadInt32();
spf.frames[i] = new SPFFrame(left, top, width, height, startAddress, byteWidth, length, semiLength);
}
spf.length = reader.ReadInt32();
for (int i = 0; i < spf.expectedFrames; ++i)
{
int length = spf.frames[i].Length;
byte[] data = reader.ReadBytes(length);
spf.frames[i].SetData(data);
}
reader.Close();
return(spf);
}
