Wolfenstein 3D: Экспортируем карты уровней и объекты на них

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Threading.Tasks;

namespace Wolfenstein3DMapGrabber
{
    class Wolfenstein3DMapGrabber
    {

        /*
         * Start
         */
        static void Main(string[] args)
        {
            string ProjectPath = System.IO.Directory.GetCurrentDirectory();
            Int32[] Offsets;

            if ((Offsets = Wolfenstein3DMapGrabber.ParseMapHeadFile(ProjectPath + "/Wolfenstein3DData/MAPHEAD.WL6")).Length > 0)
            {
                Console.WriteLine("MAPHEAD.WL6: Data received (Blocks count = " + Offsets.Length + ")");
                Wolfenstein3DMapGrabber.ParseMapDataFile(ProjectPath + "/Wolfenstein3DData/GAMEMAPS.WL6", Offsets);

            }
            Console.WriteLine("Something done! Press any key...");
            Console.ReadKey();
        }


        /*
         * Прочитать блок заданной длинны из стрима
         */
        private static byte[] ReadBytes(FileStream Stream, int Offset, int Length)
        {
            byte[] BuffBytes = new byte[Length];
            int BytesRead = 0;

            Stream.Seek(Offset, SeekOrigin.Begin);
            if ((BytesRead = Stream.Read(BuffBytes, 0, Length)) < Length)
            {
                Stream.Close();
                throw new Exception("FATAL: IO error (" + Length + " vs. " + BytesRead + ")");
            }
            return BuffBytes;
        }


        /*
         * Декодировать ("декармакизировать") данные по карте (unhuffman)
         * а-ля CAL_CarmackExpand в оригинале
         */
        private static ushort[] DecodeMapDataFile(byte[] Input, short NumberBytesAfterDecoding)
        {
            int WordCounter;
            int InCounter;
            int OutCounter;
            ushort Copy;
            ushort[] Output;
            byte Low;
            byte High;
            int Offset;
            
            WordCounter = NumberBytesAfterDecoding / 2;
            InCounter = 0;
            OutCounter = 0;
            Output = new ushort[WordCounter];

            do
            {
                Low = Input[InCounter++];
                High = Input[InCounter++];
                if (High == 0xA7)
                {
                    // If high byte of value is A7 then:
                    if (Low == 0)
                    {
                        // If low byte is 00 then:
                        //  - high byte of value is A7
                        //  - low  byte of value is the next byte
                        Output[OutCounter++] = (ushort)((High << 8) | Input[InCounter]);
                        ++InCounter;
                        --WordCounter;
                    }
                    else
                    {
                         // - the low  byte is a count (ie. # of integers we want to reuse).
                         // - the next byte is the # of integers we want to move back in order to reuse data we have already decoded.
                        Offset = Input[InCounter];
                        ++InCounter;
                        Copy = (ushort)(OutCounter - Offset);
                        WordCounter -= Low;
                        while (Low-- != 0)
                        {
                            Output[OutCounter++] = Output[Copy++];
                        }
                    }
                }
                else if (High == 0xA8)
                {
                    // If high byte of value is A8 then:
                    if (Low == 0)
                    {
                        // If low byte is 00 then:
                        //  - high byte of value is A8
                        //  - low  byte of value is the next byte
                        Output[OutCounter++] = (ushort)((High << 8) | Input[InCounter]);
                        ++InCounter;
                        --WordCounter;
                    }
                    else
                    {
                        // - the low  byte is a count (ie. # of integers we want to reuse).
                        // - the next integer (2 bytes) is the # of integers
                        //   we want to skip over, starting at the beginning of the buffer being used to hold data we have already decoded 
                        //   (the first integer in the buffer being the # of bytes after decompressing).
                        Offset = (ushort)((Input[InCounter + 1] << 8) | Input[InCounter]);
                        InCounter += 2;
                        Copy = (ushort)(0 + Offset - 1);
                        WordCounter -= Low;
                        while (Low-- != 0)
                        {
                            Output[OutCounter++] = Output[Copy++];
                        }
                    }
                }
                else
                {
                    // If high byte is not A7 or A8, then store the value as is.
                    Output[OutCounter++] = (ushort)((High << 8) | Low);
                    --WordCounter;
                }
            } while (WordCounter != 0);
            return Output;
        }


        /*
         * Распаковать данные (unRLEW)
         */
        private static ushort[] DecompressMapDataFile(ushort[] Data, short NumberOfBytesAfterDecompressing)
        {
            int WordsCount = NumberOfBytesAfterDecompressing / 2;
            ushort[] Output = new ushort[WordsCount];
            uint InCounter = 0;
            uint OutCounter = 0;
            ushort Number = 0;
            ushort Repeat;
            
            do
            {
                Number = Data[InCounter++];
                if (Number == 0xABCD)
                {
                    // If value == ABCD
                    //  - the next integer is # of repetitions
                    //  - the next integer is value to repeat
                    Repeat = Data[InCounter++];
                    Number = Data[InCounter++];
                    WordsCount -= Repeat;
                    while (Repeat-- > 0) 
                    {
                        Output[OutCounter++] = Number;
                    }
                }
                else 
                {
                    // If value is not ABCD then store the value as is.
                    Output[OutCounter++] = Number;
                    WordsCount--;
                }
            } while (WordsCount > 0);

            return Output;
        }


        /*
         * Разбираем GAMEMAPS файл
         */
        private static bool ParseMapDataFile(string FileName, Int32[] Offsets)
        {
            int Length = 0;
            FileStream Stream;
            byte[] BuffBytes;
            Int32 DataShift = 0;
            Int32 DataLength = 0;
            short NumberBytesAfterDecoding;
            short NumberOfBytesAfterDecompressing;
            ushort[] Data;
            string ExportData;
            string LevelName;
            int[] Shifts;
            string FileNameSuffix;

            Stream = new FileStream(FileName, FileMode.Open, FileAccess.Read);
            Length = (int)Stream.Length;
            Shifts = new int[] { 0, 1 };
            // забираем данные по заголовкам карт
            for (int i = 0; i < Offsets.Length; ++i)
            {
                if (Offsets[i] > 0)
                {
                    for (int k = 0; k < Shifts.Length; ++k)
                    {
                        if (Shifts[k] == 0)
                        {
                            FileNameSuffix = "-Map";
                        }
                        else 
                        {
                            FileNameSuffix = "-Objects";
                        }

                        /*
                        Level
                        Header  Data
                        Offset  Type  Description
                        ------  ----  -------------------------------
                        0000   long  File offset of Map_Block
                        0004   long  File offset of Object_Block
                        0008   long  File offset of Unknown_Block
                        000C   int   File size   of Map_Block
                        000E   int   File size   of Object_Block
                        0010   int   File size   of Unknown_Block
                        0012   int   Horizontal map size (# of squares)
                        0014   int   Vertical   map size (# of squares)
                        0016   char  Level name (ascii) (null terminated)
                        0026   char  "!ID!" (4 bytes)
                        */

                        DataShift = BitConverter.ToInt32(Wolfenstein3DMapGrabber.ReadBytes(Stream, Offsets[i] + Shifts[k] * 4, 4), 0);
                        DataLength = BitConverter.ToInt16(Wolfenstein3DMapGrabber.ReadBytes(Stream, Offsets[i] + 12 + Shifts[k] * 2, 2), 0);

                        /*
                        Block  Data
                        Offset Type Description
                        ------ ---- --------------------------------------------
                        0000  int  # of data bytes after decoding (count includes the two bytes at Block Offset 0002).
                        0002  int  # of data bytes after decompresssing.
                        0004  int  Data bytes. Values are stored as 2 byte integers (low byte first).
                        */

                        NumberBytesAfterDecoding = BitConverter.ToInt16(Wolfenstein3DMapGrabber.ReadBytes(Stream, DataShift, 2), 0);
                        NumberOfBytesAfterDecompressing = BitConverter.ToInt16(Wolfenstein3DMapGrabber.ReadBytes(Stream, DataShift + 2, 2), 0);
                        BuffBytes = Wolfenstein3DMapGrabber.ReadBytes(Stream, DataShift + 4, DataLength);
                        LevelName = System.Text.Encoding.ASCII.GetString(Wolfenstein3DMapGrabber.ReadBytes(Stream, Offsets[i] + 22, 16)).Replace("\0", "");

                        Console.WriteLine("GAMEMAPS.WL6:");
                        Console.WriteLine("     LEVEL " + i);
                        Console.WriteLine("     DATA OFFSET: " + Offsets[i]);
                        Console.WriteLine("     NAME: " + LevelName);
                        Console.WriteLine("     NUMBER OF BYTES AFTER DECODING: " + NumberBytesAfterDecoding);
                        Console.WriteLine("     NUMBER OF BYTES AFTER DECOMPRESSING: " + NumberOfBytesAfterDecompressing);
                        Console.WriteLine("     BUFFER LENGTH: " + BuffBytes.Length);

                        // Pass1 (decoding):
                        Data = Wolfenstein3DMapGrabber.DecodeMapDataFile(BuffBytes, NumberBytesAfterDecoding);
                        // Pass2 (decompressing):
                        Data = Wolfenstein3DMapGrabber.DecompressMapDataFile(Data, NumberOfBytesAfterDecompressing);
                        // Export decompressing data
                        ExportData = "";
                        for (int j = 0; j < Data.Length; j++)
                        {
                            if (ExportData != "")
                            {
                                ExportData += ",";
                            }
                            ExportData += Data[j].ToString();
                        }
                        System.IO.StreamWriter OutputFile = new System.IO.StreamWriter(@".\" + LevelName + FileNameSuffix + ".txt");
                        OutputFile.WriteLine(ExportData);
                        OutputFile.Close();
                    }
                }
            }
            Stream.Close();
            return false;
        }


        /*
         * Разобрать MAPHEAD файл
         */
        private static Int32[] ParseMapHeadFile(string FileName)
        {
            int Length = 0;
            int Iteration = 0;
            int DataLength = 0;
            int BlockLengthInBytes = 4;
            FileStream Stream;
            Int32[] Offsets;
            byte[] BuffBytes;

            try
            {
                if (!File.Exists(FileName))
                {
                    throw new Exception("MAPHEAD.WL6: File not exists");
                }
                Stream = new FileStream(FileName, FileMode.Open, FileAccess.Read);
                Length = (int)Stream.Length;
                BuffBytes = Wolfenstein3DMapGrabber.ReadBytes(Stream, 0, 2);
                // первые 2 байта - ключ для декомпрессии (см. DecompressMapDataFile)
                if (BuffBytes[0] != 0xCD || BuffBytes[1] != 0xAB)
                {
                    throw new Exception("MAPHEAD.WL6: Wrong file format");
                }
                DataLength = Length - 2;
                if (DataLength <= 0 || DataLength % BlockLengthInBytes != 0)
                {
                    throw new Exception("MAPHEAD.WL6: Wrong file format");
                }
                Offsets = new Int32[DataLength / BlockLengthInBytes];
                Length = 2;
                // файл содержит в себе набор int'ов (смещений в файле GAMEMAPS)
                while ((BuffBytes = Wolfenstein3DMapGrabber.ReadBytes(Stream, Length, BlockLengthInBytes)).Length > 0)
                {
                    Length += BuffBytes.Length;
                    Offsets[Iteration] = BitConverter.ToInt32(BuffBytes, 0);
                    Iteration++;
                    if (Iteration == Offsets.Length)
                    {
                        Stream.Close();
                        return Offsets;
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
            return new Int32[0];
        }

    }
}