Работа с файлами неизвестных форматов. Анализ структуры, написание редактора.

class Program
    {
        static void Main(string[] args)
        {
            FileInfo file = new FileInfo(args[0]);
            byte[] buff = new byte[17];

            using (FileStream stream = new FileStream(file.FullName, FileMode.Open, FileAccess.Read))
            {
                stream.Read(buff, 0, 4);
                UInt32 count = BitConverter.ToUInt32(buff, 0) - 1;
                Console.WriteLine(String.Format("Распаковка файла: {0}", file.Name));
                Console.WriteLine(String.Format("Количество файлов: {0}", count));
                Console.WriteLine("-------------------");

                FileHeader[] files = new FileHeader[count];
                for (UInt32 index = 0; index <= count; index++)
                {
                    stream.Read(buff, 0, 17);
                    FileHeader fs = new FileHeader(BitConverter.ToUInt32(buff, 0), Encoding.GetEncoding(1251).GetString(buff, 4, 12).TrimEnd(new char[] { '\0' }));
                    if (index != count)
                    {
                        files[index] = fs;
                    }
                    if (index != 0)
                    {
                        files[index - 1].lenght = fs.shift - files[index - 1].shift;
                    }
                }

                DirectoryInfo dir = new DirectoryInfo(file.FullName + "_");
                if (!dir.Exists) dir.Create();
               
                foreach (FileHeader s in files)
                {
                    Console.WriteLine(String.Format("|Файл: {0} | Смещение:  {1:x}| Длина:  {2}", s.name, s.shift, s.lenght));
                    stream.Position = s.shift;
                    byte[] b = new byte[s.lenght];
                    stream.Read(b, 0, (int)s.lenght);
                    using (FileStream output = new FileStream(String.Format(@"{0}\{1}", dir.FullName, s.name), FileMode.Create, FileAccess.Write))
                    {
                        output.Write(b, 0, (int)s.lenght);
                    }
                }
            }
        }
    }

    public class FileHeader
    {
        public UInt32 shift = 0;
        public UInt32 lenght = 0;
        public string name = "";

        public FileHeader(UInt32 shift, string name)
        {
            this.shift = shift;
            this.name = name;
        }
    }

Console.WriteLine("Распаковка файла: {0}", file.Name);

namespace BoYRepacker
{
    class Program
    {
        static void Main(string[] args)
        {
            Mode mode = Mode.Unpack; // режим работы - упаковка или распаковка
            FileInfo file = new FileInfo("Z:\\z.tmp"); // DAT-архив
            DirectoryInfo dir = new DirectoryInfo("Z:\\"); // папка с файлами

            // Проверка количества аргументов
            if (args.Length < 3) { onDone(2, args.Length); }

            // Парсинг аргументов
            switch (args[0])
            {
                case "p":
                    mode = Mode.Pack;
                    file = new FileInfo(args[args.Length - 1]);
                    dir = new DirectoryInfo(args[args.Length - 2]);
                    break;
                case "u":
                    mode = Mode.Unpack;
                    file = new FileInfo(args[args.Length - 2]);
                    dir = new DirectoryInfo(args[args.Length - 1]);
                    break;
                default: onDone(3, args[0]); break;
            }

            // Проверка существования входного объекта
            if ((mode == Mode.Pack) && !dir.Exists)
                onDone(4, dir.FullName);
            if ((mode == Mode.Unpack) && !file.Exists)
                onDone(4, file.FullName);

            // Проверка существования выходного объекта
            if (!(args.Contains<string>("/y") || args.Contains<string>("/Y")))
            {
                bool outputExist = false;
                if ((mode == Mode.Pack) && file.Exists)
                    outputExist = true;
                if ((mode == Mode.Unpack) && dir.Exists)
                    outputExist = true;
                if (outputExist)
                {
                    Console.WriteLine("Выходной объект уже существует! Вы уверены, что хотите перезаписать его?");
                    Console.WriteLine("Перезаписать {0}? [Y - да, N - нет]", (mode == Mode.Pack ? file.FullName : dir.FullName));
                    while (true)
                    {
                        int c = Console.Read();
                        if ((c == -1) || ((char)c == 'n') || ((char)c == 'N')) { onDone(1); }
                        else if (((char)c == 'y') || ((char)c == 'Y')) { break; }
                    }
                }
            }

            // Создаем несуществующие папки
            if (!file.Directory.Exists)
                file.Directory.Create();
            if (!dir.Exists)
                dir.Create();

            // Запуск операции
            if (mode == Mode.Pack) { pack(file, dir); } else { unpack(file, dir); }
        }

        /// <summary>
        /// Упаковка папки
        /// </summary>
        /// <param name="file">Выходной DAT-файл</param>
        /// <param name="dir">Входная папка</param>
        static void pack(FileInfo file, DirectoryInfo dir)
        {
            // Пишем-с
            using (FileStream stream = new FileStream(file.FullName, FileMode.Create, FileAccess.Write))
            {
                FileInfo[] files = dir.GetFiles("*", SearchOption.TopDirectoryOnly);
                byte[] header = new byte[4 + 17 * (files.Length + 1)];

                Console.WriteLine("Упаковка файла:     {0}", file.Name);
                Console.WriteLine("Количество файлов:   {0}", files.Length);
                Console.WriteLine("-----------------------------------");

                // Записываем количество файлов (+1 пустышка)
                stream.Write(BitConverter.GetBytes(files.Length + 1), 0, 4);

                // Пишем заголовок
                UInt32 shift = (UInt32)(4 + 17 * (files.Length + 1));                
                for (int i = 0; i < files.Length; i++)
                {
                    shift += (UInt32)(i > 0 ? files[i - 1].Length : 0);
                    byte[] name = new byte[13];
                    Encoding.GetEncoding(1251).GetBytes(files.Name).CopyTo(name, 0);
                    stream.Write(BitConverter.GetBytes(shift), 0, 4);
                    stream.Write(name, 0, 13);
                    Console.WriteLine("| Файл: {0}  | Смещение: {1:x}   |", files.Name, shift);
                }
                // Не забываем несуществующий объект, для вычисления длины последнего файла
                shift += (UInt32)(files[files.Length - 1].Length);
                stream.Write(BitConverter.GetBytes(shift), 0, 4);
                stream.Write(new byte[13], 0, 13);
                Console.WriteLine("-----------------------------------");

                // Последовательно записываем файлы один за другим
                for (int i = 0; i < files.Length; i++)
                {
                    using (FileStream f = new FileStream(files.FullName, FileMode.Open, FileAccess.Read))
                    {
                        Console.WriteLine("| Файл: {0}  | Смещение: {1:x}   | Размер: {2} |", files.Name, stream.Position, (int)files.Length);
                        byte[] buff = new byte[files.Length];
                        f.Read(buff, 0, (int)files.Length);
                        stream.Write(buff, 0, (int)files.Length);
                    }
                }
            }
        }
       
        /// <summary>
        /// Распаковка архива
        /// </summary>
        /// <param name="file">DAT-файл</param>
        /// <param name="dir">Выходная папка</param>
        static void unpack(FileInfo file, DirectoryInfo dir)
        {
            // Читаем-с
            using (FileStream stream = new FileStream(file.FullName, FileMode.Open, FileAccess.Read))
            {
                // Считываем количество файлов
                byte[] header = new byte[4];
                stream.Read(header, 0, 4);
                UInt32 count = BitConverter.ToUInt32(header, 0);

                Console.WriteLine("Распаковка файла: {0}", file.Name);
                Console.WriteLine("Количество файлов:   {0}", count - 1);
                Console.WriteLine("-----------------------------------");

                // Считываем заголовок
                header = new byte[count * 17];
                stream.Read(header, 0, (int)(count * 17));
               
                byte[] buff;
                for (UInt32 index = 0; index < count - 1; index++)
                {
                    UInt32 shift = BitConverter.ToUInt32(header, (int)(index * 17));
                    UInt32 length = BitConverter.ToUInt32(header, (int)((index + 1) * 17)) - shift;
                    string name = Encoding.GetEncoding(1251).GetString(header, (int)(4 + index * 17), 12);

                    Console.WriteLine("| Файл: {0} | Смещение: {1:x}    | Длина: {2}   |", name, shift, length);

                    buff = new byte[length];
                    stream.Position = shift;
                    stream.Read(buff, 0, (int)length);
                   
                    using (FileStream output = new FileStream(String.Format(@"{0}\{1}", dir.FullName, name.TrimEnd(new char[] { '\0' })), FileMode.Create, FileAccess.Write))
                    {
                        output.Write(buff, 0, (int)length);
                    }
                }
            }
        }

        // Вывод сообщения о завершении работы и выход из программы
        static void onDone(int exitCode, object param = null)
        {
            switch (exitCode)
            {
                case 0:
                    Console.WriteLine("Операция успешно завершена.");
                    break;
                case 1:
                    Console.WriteLine("Операция прервана пользователем.");
                    break;
                case 2:
                    Console.WriteLine("Неверное число параметров: {0}" + Environment.NewLine, param);
                    goto default;
                case 3:
                    Console.WriteLine("Неизвестный ключ запуска: {0}" + Environment.NewLine, param);
                    goto default;
                case 4:
                    Console.WriteLine("Входной объект не существует: {0}" + Environment.NewLine, param);
                    goto default;
                default:
                    Console.WriteLine("Распаковка или упаковка игровых архивов Battle of the Youstrass.");
                    Console.WriteLine("2011 (c) Vitamant [vitamant@gmail.com]" + Environment.NewLine);
                    Console.WriteLine("{0} [p | u] [/Y] источник результат" + Environment.NewLine, Process.GetCurrentProcess().ProcessName);
                    Console.WriteLine("  p      Упаковка входной папки в выходной DAT-архив.");
                    Console.WriteLine("  u      Распаковка входного DAT-архива в выходную папку.");
                    Console.WriteLine("  /Y     Подтверждение перезаписи выходного объекта.");
                    Console.WriteLine("  источник   Распаковываемый DAT-архив или упаковываемая папка.");
                    Console.WriteLine("  результат Распакованная папка или упакованный DAT-архив." + Environment.NewLine);
                    break;
            }
            Environment.Exit(exitCode);
        }
    }

    /// <summary>
    /// Режим работы - распаковка или упаковка
    /// </summary>
    public enum Mode
    {
        Pack, Unpack
    }
}

C1A0C1A0C1A0C1A0C1A0C1A0C1A0C1A0
C1ACC1ACC1A5C1A0C1A0C1A0C1A0C1A5
C1A0C1A2C1A2C1B3C1BEC1ACC1A5C1A5
C1ACC1ACC1ACC1ACC1A0C1A2C1A2C1A2

FFA0FFA0C2A0C2ACA5C4A0A5A0C2A2B3

C 1100 - 0      A 1010 - 0
D 1101 - 1      B 1011 - 1
E 1110 - 2      8 1000 - 2
F 1111 - 3      9 1001 - 3
8 1000 - 4      E 1110 - 4
9 1001 - 5      F 1111 - 5
A 1010 - 6      C 1100 - 6
B 1011 - 7      D 1101 - 7
4 0100 - 8      2 0011 - 8
5 0101 - 9      3 0011 - 9
6 0110 - 10     0 0000 - 10
7 0111 - 11     1 0001 - 11
0 0000 - 12     6 0110 - 12
1 0001 - 13     7 0111 - 13
2 0010 - 14     4 0100 - 14
3 0011 - 15     5 0101 - 15