Esempio n. 1
0
 static private void ReadStrings(ZInputStream Inflater, int count, string[] target)
 {
     byte[] byte2 = new byte[2];
     for (int i = 0; i < count; ++i)
     {
         if (Inflater.Read(byte2) == 0)
         {
             throw new Exception("Error: byte = 0");
         }
         int    length  = ByteConverter.getShort(byte2, 0);
         byte[] message = new byte[length];
         Inflater.Read(message);
         target[i] = Encoding.UTF8.GetString(message);
     }
 }
Esempio n. 2
0
        private byte[] GetContentHelperFunc(FileStream fStream)
        {
            var buffer = new byte[FileSize]; //Will contain compressed data

            fStream.Seek(FileOffset, SeekOrigin.Begin);
            fStream.Read(buffer, 0, (int)FileSize);

            try
            {
                var mStream = new MemoryStream(buffer);
                var zinput  = new ZInputStream(mStream);

                var dBuffer = new List <byte>(); //decompressed buffer, arraylist to my knowledge...

                //This could be optimized in the future by reading a block and adding it to our arraylist..
                //which would be much faster, obviously
                int data;
                while ((data = zinput.Read()) != -1)
                {
                    dBuffer.Add((byte)data);
                }

                return(dBuffer.ToArray());
            }
            catch
            {
                //it's not compressed, just return original content
                return(buffer);
            }
        }
Esempio n. 3
0
        /// <summary>
        /// Returns the content of the actual file (extracts from raf archive)
        /// </summary>
        public byte[] GetContent()
        {
            if (inMemory)
            {
                throw new Exception("Invalid call to GetContent, this entry is only in memory, and has not been linked to the DAT file yet.");
            }

            byte[] buffer = new byte[this.FileSize]; //Will contain compressed data
            //lock (this.raf) //No longer necessary
            {
                //Todo: Since we are no longer modifying the data file content stream,
                //      it would be valid to create the stream more than once.
                //      We could then work WHILE reading.
                FileStream fStream = new FileStream(archive.DatFilePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite); //this.raf.GetDataFileContentStream();
                fStream.Seek(this.FileOffset, SeekOrigin.Begin);
                fStream.Read(buffer, 0, (int)this.FileSize);
                fStream.Close();
            }
            try
            {
//            using (var outputMs = new MemoryStream()) {
//
//               var deflate = new DeflateStream(new MemoryStream(buffer, 2, buffer.Length - 2), CompressionMode.Decompress);
//               deflate.CopyTo(outputMs);
//               return outputMs.ToArray();
//            }
                ZInputStream zinput = new ZInputStream(new MemoryStream(buffer));
                MemoryStream ms     = new MemoryStream();
                int          data   = 0;
                while ((data = zinput.Read()) != -1)
                {
                    ms.WriteByte((byte)data);
                }
                return(ms.ToArray());

                //            new DeflateStream()
                //
                //            //List<byte> dBuffer = new List<byte>(); //decompressed buffer, arraylist to my knowledge...
                //
                //            MemoryStream ms = new MemoryStream();
                //
                //            //This could be optimized in the future by reading a block and adding it to our arraylist..
                //            //which would be much faster, obviously
                //            int data = 0;
                //            while ((data = zinput.Read()) != -1)
                //               ms.WriteByte((byte)data);
                //            //dBuffer.Add((byte)data);
                //            //ComponentAce.Compression.Libs.zlib.ZStream a = new ComponentAce.Compression.Libs.zlib.ZStream();
                //
                //            //File.WriteAllBytes((dumpDir + entry.FileName).Replace("/", "\\"), dBuffer.ToArray());
                //            return ms.ToArray();
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                //it's not compressed, just return original content
                return(buffer);
            }
        }
Esempio n. 4
0
        public static void DecompressFile(string inFile, string outFile)
        {
            int       data;
            const int stopByte      = -1;
            var       outFileStream = new FileStream(outFile, FileMode.Create);
            var       inZStream     = new ZInputStream(File.Open(inFile, FileMode.Open, FileAccess.Read));

            while (stopByte != (data = inZStream.Read()))
            {
                var databyte = (byte)data;
                outFileStream.WriteByte(databyte);
            }

            inZStream.Close();
            outFileStream.Close();
        }
Esempio n. 5
0
        private static void UncompressFile(string inFile, string outFile)
        {
            // Do it slow way because calling CopyStream sometimes causes an inflated exception on LoL comrpessed files
            int stopByte = -1;

            System.IO.FileStream outFileStream = new System.IO.FileStream(outFile, System.IO.FileMode.Create);
            ZInputStream         inZStream     = new ZInputStream(System.IO.File.Open(inFile, System.IO.FileMode.Open, System.IO.FileAccess.Read));
            int data;

            while (stopByte != (data = inZStream.Read()))
            {
                byte _dataByte = (byte)data;
                outFileStream.WriteByte(_dataByte);
            }
            inZStream.Close();
            outFileStream.Close();
        }
Esempio n. 6
0
        public static OSD ZDecompressBytesToOsd(byte[] input)
        {
            OSD osd = null;

            using (MemoryStream msSinkUnCompressed = new MemoryStream())
            {
                using (ZInputStream zOut = new ZInputStream(msSinkUnCompressed))
                {
                    zOut.Read(input, 0, input.Length);
                    msSinkUnCompressed.Seek(0L, SeekOrigin.Begin);
                    osd = OSDParser.DeserializeLLSDBinary(msSinkUnCompressed.ToArray());
                    zOut.Close();
                }
            }

            return(osd);
        }
        public static void uncompressFile(string inFile, string outFile)
        {
            int data     = 0;
            int stopByte = -1;

            System.IO.FileStream outFileStream = new System.IO.FileStream(outFile, System.IO.FileMode.Create);
            ZInputStream         inZStream     = new ZInputStream(System.IO.File.Open(inFile, System.IO.FileMode.Open, System.IO.FileAccess.Read));

            while (stopByte != (data = inZStream.Read()))
            {
                byte _dataByte = (byte)data;
                outFileStream.WriteByte(_dataByte);
            }

            inZStream.Close();
            outFileStream.Close();
        }
Esempio n. 8
0
        /// <summary>
        /// Распаковка файла
        /// </summary>
        /// <param name="fileName">Путь к файлу</param>
        /// <param name="state"></param>
        /// <returns></returns>
        public string BackProcessExecute(string fileName)
        {
            int    data     = 0;
            int    stopByte = -1;
            string out_file = TempNameGenerator.GenerateTempNameFromFile(fileName);

            using (FileStream outFileStream = new FileStream(out_file, FileMode.Create))
            {
                using (ZInputStream inZStream = new ZInputStream(File.Open(fileName, FileMode.Open, FileAccess.Read)))
                {
                    while (stopByte != (data = inZStream.Read()))
                    {
                        byte _dataByte = (byte)data;
                        outFileStream.WriteByte(_dataByte);
                    }
                    inZStream.Close();
                }
                outFileStream.Close();
            }
            return(out_file);
        }
Esempio n. 9
0
        public void uncompressFile(string inFile, string outFile)
        {
            try
            {
                int data     = 0;
                int stopByte = -1;
                System.IO.FileStream outFileStream = new System.IO.FileStream(outFile, System.IO.FileMode.Create);
                ZInputStream         inZStream     = new ZInputStream(System.IO.File.Open(inFile, System.IO.FileMode.Open, System.IO.FileAccess.Read));
                while (stopByte != (data = inZStream.Read()))
                {
                    byte _dataByte = (byte)data;
                    outFileStream.WriteByte(_dataByte);
                }

                inZStream.Close();
                outFileStream.Close();
            }
            catch
            {
                Client.Log("Unable to find a file to uncompress");
            }
        }
Esempio n. 10
0
        public void UncompressFile(string inFile, string outFile)
        {
            try
            {
                int       data;
                const int stopByte      = -1;
                var       outFileStream = new FileStream(outFile, FileMode.Create);
                var       inZStream     = new ZInputStream(File.Open(inFile, FileMode.Open, FileAccess.Read));
                while (stopByte != (data = inZStream.Read()))
                {
                    var dataByte = (byte)data;
                    outFileStream.WriteByte(dataByte);
                }

                inZStream.Close();
                outFileStream.Close();
            }
            catch
            {
                Client.Log("Unable to find a file to uncompress");
            }
        }
Esempio n. 11
0
        public void ReadPacket(Stream s)
        {
            int slen = 0;

            byte[] rdata;

            VarInt viPacketLength = new VarInt(s);

            PacketLength = VarintBitConverter.ToInt32(viPacketLength.VarIntData);

            VarInt viPacketID;

            if (Compression == false)
            {
                viPacketID = new VarInt(s);
                PacketId   = VarintBitConverter.ToInt32(viPacketID.VarIntData);

                DataLength = PacketLength - viPacketID.Length;
                Data       = new byte[DataLength];


                if (s.Read(Data, 0, DataLength) == DataLength)
                {
                    DataRead = true;
                }
                else
                {
                    DataRead = false;
                }
            }
            else
            {
                VarInt viDataLength = new VarInt(s);
                DataLength = VarintBitConverter.ToInt32(viDataLength.VarIntData);


                if (DataLength == 0)
                {
                    //No compression
                    viPacketID = new VarInt(s);
                    PacketId   = VarintBitConverter.ToInt32(viPacketID.VarIntData);
                    DataLength = PacketLength - viDataLength.Length - viPacketID.Length;
                    Data       = new byte[DataLength];

                    if (s.Read(Data, 0, DataLength) == DataLength)
                    {
                        DataRead = true;
                    }
                    else
                    {
                        DataRead = false;
                    }
                }
                else
                {
                    Data  = new byte[DataLength];
                    slen  = PacketLength - viDataLength.Length;
                    rdata = new byte[slen];

                    if (s.Read(rdata, 0, slen) == slen)
                    {
                        DataRead = true;
                    }
                    else
                    {
                        DataRead = false;
                    }

                    if (DataRead == true)
                    {
                        MemoryStream ms;

                        ms = new MemoryStream(rdata);
                        ZInputStream zlib = new ZInputStream(ms);

                        if (zlib.Read(Data, 0, DataLength) == DataLength)
                        {
                            DataRead = true;
                        }
                        else
                        {
                            DataRead = false;
                        }

                        zlib.Close();

                        ms = new MemoryStream(Data);

                        viPacketID = new VarInt(ms);
                        PacketId   = VarintBitConverter.ToInt32(viPacketID.VarIntData);

                        slen = DataLength - viPacketID.Length;


                        if (ms.Read(Data, 0, slen) == slen)
                        {
                            DataRead = true;
                        }
                        else
                        {
                            DataRead = false;
                        }

                        ms.Close();
                    }
                }
            }
        }
Esempio n. 12
0
        /// <summary>
        /// Decompresses the given data stream from its source ZIP or GZIP format.
        /// </summary>
        /// <param name="dataBytes"></param>
        /// <returns></returns>
        internal static byte[] Inflate(Stream dataStream, CompressionFormat format)
        {
            byte[] outputBytes = null;

            switch (format)
            {
            case CompressionFormat.Zlib:

                try
                {
                    var zipInputStream = new ZipInputStream(dataStream);

                    if (zipInputStream.CanDecompressEntry)
                    {
                        MemoryStream zipoutStream = new MemoryStream();
                        zipInputStream.CopyTo(zipoutStream);
                        outputBytes = zipoutStream.ToArray();
                    }
                    else
                    {
                        dataStream.Seek(0, SeekOrigin.Begin);
                        var inZInputStream = new ZInputStream(dataStream);

                        var outMemoryStream = new MemoryStream();
                        outputBytes = new byte[inZInputStream.BaseStream.Length];

                        while (true)
                        {
                            int bytesRead = inZInputStream.Read(outputBytes, 0, outputBytes.Length);
                            if (bytesRead == 0)
                            {
                                break;
                            }
                            outMemoryStream.Write(outputBytes, 0, bytesRead);
                        }
                    }
                }
                catch (Exception exc)
                {
                    CCLog.Log("Error decompressing image data: " + exc.Message);
                }
                break;

            case CompressionFormat.Gzip:

                try
                {
                    #if !WINDOWS_PHONE
                    var gzipInputStream = new GZipInputStream(dataStream, CompressionMode.Decompress);
                    #else
                    var gzipInputStream = new GZipInputStream(dataStream);
                                        #endif

                    MemoryStream zipoutStream = new MemoryStream();
                    gzipInputStream.CopyTo(zipoutStream);
                    outputBytes = zipoutStream.ToArray();
                } catch (Exception exc) {
                    CCLog.Log("Error decompressing image data: " + exc.Message);
                }
                break;
            }

            return(outputBytes);
        }
Esempio n. 13
0
        public void EndElement(object ctx, string elementName)
        {
            CCTMXMapInfo pTMXMapInfo = this;

            byte[] encoded = null;

            if (elementName == "data" && (pTMXMapInfo.LayerAttribs & (int)CCTMXLayerAttrib.Base64) != 0)
            {
                pTMXMapInfo.StoringCharacters = false;
                CCTMXLayerInfo layer = pTMXMapInfo.Layers.LastOrDefault();
                if ((pTMXMapInfo.LayerAttribs & ((int)(CCTMXLayerAttrib.Gzip) | (int)CCTMXLayerAttrib.Zlib)) != 0)
                {
                    //gzip compress
                    if ((pTMXMapInfo.LayerAttribs & (int)CCTMXLayerAttrib.Gzip) != 0)
                    {
                        try
                        {
                            GZipStream inGZipStream = new GZipStream(new MemoryStream(pTMXMapInfo.CurrentString));

                            var outMemoryStream = new MemoryStream();

                            var buffer = new byte[1024];
                            while (true)
                            {
                                int bytesRead = inGZipStream.Read(buffer, 0, buffer.Length);
                                if (bytesRead == 0)
                                {
                                    break;
                                }
                                outMemoryStream.Write(buffer, 0, bytesRead);
                            }
                            encoded = outMemoryStream.ToArray();
                        }
                        catch (Exception ex)
                        {
                            CCLog.Log("failed to decompress embedded data object in TMX file.");
                            CCLog.Log(ex.ToString());
                        }
                    }

                    //zlib
                    if ((pTMXMapInfo.LayerAttribs & (int)CCTMXLayerAttrib.Zlib) != 0)
                    {
                        var inZInputStream = new ZInputStream(new MemoryStream(pTMXMapInfo.CurrentString));

                        var outMemoryStream = new MemoryStream();

                        var buffer = new byte[1024];
                        while (true)
                        {
                            int bytesRead = inZInputStream.Read(buffer, 0, buffer.Length);
                            if (bytesRead == 0)
                            {
                                break;
                            }
                            outMemoryStream.Write(buffer, 0, bytesRead);
                        }

                        encoded = outMemoryStream.ToArray();
                    }
                }
                else
                {
                    encoded = pTMXMapInfo.CurrentString;
                }

                for (int i = 0; i < layer.Tiles.Length; i++)
                {
                    int i4  = i * 4;
                    var gid = (uint)(
                        encoded[i4] |
                        encoded[i4 + 1] << 8 |
                            encoded[i4 + 2] << 16 |
                            encoded[i4 + 3] << 24);

                    layer.Tiles[i] = gid;
                }

                pTMXMapInfo.CurrentString = null;
            }
            else if (elementName == "map")
            {
                // The map element has ended
                pTMXMapInfo.ParentElement = (int)CCTMXProperty.None;
            }
            else if (elementName == "layer")
            {
                // The layer element has ended
                pTMXMapInfo.ParentElement = (int)CCTMXProperty.None;
            }
            else if (elementName == "objectgroup")
            {
                // The objectgroup element has ended
                pTMXMapInfo.ParentElement = (int)CCTMXProperty.None;
            }
            else if (elementName == "object")
            {
                // The object element has ended
                pTMXMapInfo.ParentElement = (int)CCTMXProperty.None;
            }
        }
Esempio n. 14
0
        static void Main(string[] args)
        {
            FileStream fs = new FileStream("D:\\bloomextract.bls", FileMode.Open, FileAccess.Read);

            try
            {
                ZInputStream zIn         = new ZInputStream(fs);
                int          curPosition = 0;
                Byte[]       data        = new Byte[4096];
                Byte[]       bytes       = new Byte[0];
                while (true)
                {
                    int size = zIn.Read(data, 0, data.Length);
                    if (size > 0)
                    {
                        curPosition += size;
                        Byte[] tempBytes = new Byte[bytes.LongLength + data.Length];

                        bytes.CopyTo(tempBytes, 0);
                        data.CopyTo(tempBytes, bytes.LongLength);

                        bytes = tempBytes;
                    }
                    else
                    {
                        break;
                    }
                }
                string str = System.Text.Encoding.Default.GetString(bytes);
                Console.WriteLine(str);
                Console.WriteLine("ddddddddddd");
                bytes = deCompressBytes(bytes);
                str   = System.Text.Encoding.Default.GetString(bytes);
                Console.WriteLine(str);
                fs.Close();
                fs.Dispose();

                //string strDecompress = System.Text.Encoding.UTF8.GetString(bytesDecompress);
                //Console.WriteLine(strDecompress);
                //BLS p = new BLS(buffur);
                //byte[] re = new ShaderBlock(buffur).Serialize();

                using (FileStream fs1 = new FileStream("D:\\bloom.bls", FileMode.OpenOrCreate, FileAccess.ReadWrite))
                {
                    using (BinaryWriter bw = new BinaryWriter(fs1))
                    {
                        bw.Write(bytes);
                        bw.Close();
                    }
                }
            }
            catch
            {
            }
            finally
            {
                if (fs != null)

                {
                    //关闭资源
                    fs.Close();
                }
            }


            Console.WriteLine("Hello World!");
            Console.ReadLine();
        }
Esempio n. 15
0
        public void endElement(object ctx, string elementName)
        {
            CCTMXMapInfo cCTMXMapInfo = this;

            byte[] currentString = cCTMXMapInfo.CurrentString;
            if (!(elementName == "data") || (cCTMXMapInfo.LayerAttribs & 2) == 0)
            {
                if (elementName == "map")
                {
                    cCTMXMapInfo.ParentElement = 0;
                    return;
                }
                if (elementName == "layer")
                {
                    cCTMXMapInfo.ParentElement = 0;
                    return;
                }
                if (elementName == "objectgroup")
                {
                    cCTMXMapInfo.ParentElement = 0;
                    return;
                }
                if (elementName == "object")
                {
                    cCTMXMapInfo.ParentElement = 0;
                }
                return;
            }
            cCTMXMapInfo.StoringCharacters = false;
            CCTMXLayerInfo cCTMXLayerInfo = cCTMXMapInfo.Layers.LastOrDefault <CCTMXLayerInfo>();

            if ((cCTMXMapInfo.LayerAttribs & 12) == 0)
            {
                for (int i = 0; i < (int)cCTMXLayerInfo.m_pTiles.Length; i++)
                {
                    cCTMXLayerInfo.m_pTiles[i] = currentString[i * 4];
                }
            }
            else
            {
                using (MemoryStream memoryStream = new MemoryStream(currentString, false))
                {
                    if ((cCTMXMapInfo.LayerAttribs & 4) != 0)
                    {
                        using (GZipInputStream gZipInputStream = new GZipInputStream(memoryStream))
                        {
                            using (BinaryReader binaryReader = new BinaryReader(gZipInputStream))
                            {
                                for (int j = 0; j < (int)cCTMXLayerInfo.m_pTiles.Length; j++)
                                {
                                    cCTMXLayerInfo.m_pTiles[j] = binaryReader.ReadInt32();
                                }
                            }
                        }
                    }
                    if ((cCTMXMapInfo.LayerAttribs & 8) != 0)
                    {
                        using (ZInputStream zInputStream = new ZInputStream(memoryStream))
                        {
                            for (int k = 0; k < (int)cCTMXLayerInfo.m_pTiles.Length; k++)
                            {
                                cCTMXLayerInfo.m_pTiles[k] = zInputStream.Read();
                                zInputStream.Read();
                                zInputStream.Read();
                                zInputStream.Read();
                            }
                        }
                    }
                }
            }
            cCTMXMapInfo.CurrentString = null;
        }
Esempio n. 16
0
        public static SCX Load(string srcfile)
        {
            SCX        scx         = new SCX();
            FileStream InputStream = File.OpenRead(srcfile);

            byte[] byte16 = new byte[16];
            byte[] byte4  = new byte[4];
            byte[] byte2  = new byte[2];
            byte[] byte1  = new byte[1];

            ///////////////////HEADER//////////////////////////////////

            InputStream.Read(byte4); //version number
            scx.version = Encoding.UTF8.GetString(byte4);

            InputStream.Read(byte4); //Length of header
            InputStream.Read(byte4); //Can you save in this scenario?
            InputStream.Read(byte4); //Timestamp of last save
            InputStream.Read(byte4); //Scenario Instructions

            scx.briefing_length = 0;
            byte[] briefing = new byte[scx.briefing_length];

            InputStream.Read(briefing);
            scx.briefing = Encoding.UTF8.GetString(briefing);

            InputStream.Read(byte4); //Individual victories used
            InputStream.Read(byte4); //Player count

            scx.player_count[0] = 0;

            ///////////////////BODY//////////////////////////////////

            ZInputStream Inflater = new ZInputStream(InputStream);

            Inflater.Read(byte4);
            scx.next_unit_id = 0;
            Inflater.Read(byte4);
            scx.version2 = 0;

            //player names
            byte[] name = new byte[SCX.NAME_LENGTH];
            for (int i = 0; i < SCX.PLAYER_MAX_16; ++i)
            {
                Inflater.Read(name);
                scx.players[i].name = "zorksox";//new String(pname).trim();
                Console.WriteLine(Encoding.UTF8.GetString(name));
            }



            //player strings
            for (int i = 0; i < SCX.PLAYER_MAX_16; ++i)
            {
                Inflater.Read(name);
                scx.players[i].name_st = 0;
            }

            //player config
            for (int i = 0; i < SCX.PLAYER_MAX_16; ++i)
            {
                Inflater.Read(name);
                scx.players[i].boolean = 0;
                Inflater.Read(name);
                scx.players[i].machine = 0;
                Inflater.Read(name);
                scx.players[i].profile = 0;
                Inflater.Read(name);
                scx.players[i].unknown = 0;
            }

            //message ????
            Inflater.Read(byte4);
            scx.message_option_0 = 0;
            Inflater.Read(byte1);
            scx.message_option_1 = (char)byte1[0];
            Inflater.Read(byte4);

            //file name
            Inflater.Read(byte2);
            short fileNameLength = ByteConverter.getShort(byte2, 0);

            Console.WriteLine(fileNameLength);
            byte[] fileName = new byte[fileNameLength];
            Inflater.Read(fileName);
            scx.filename = Encoding.UTF8.GetString(fileName);

            //# message strings
            //# 0x01 = objective
            //# 0x02 = hints
            //# 0x03 = victory
            //# 0x04 = failure
            //# 0x05 = history
            //# 0x06 = scouts
            for (int i = 0; i < SCX.MESSAGE_COUNT; ++i)
            {
                Inflater.Read(byte4);
                scx.messages_st[i] = 0;
            }

            // message scripts
            ReadStrings(Inflater, SCX.MESSAGE_COUNT, scx.messages);

            //message cinematics
            ReadStrings(Inflater, SCX.CINEMATIC_COUNT, scx.cinematics);

            //message / bitmap

            scx.bitmap.boolean = 0;
            Inflater.Read(byte4);
            scx.bitmap.width = 0;
            Inflater.Read(byte4);
            scx.bitmap.height = 0;
            Inflater.Read(byte4);
            Inflater.Read(byte2);

            //scx.bitmap.def = ByteConverter.getShort(byte2, 0);

            if (scx.bitmap.boolean > 0)
            {
                byte[] bitmap = new byte[40 + 1024 + scx.bitmap.width * scx.bitmap.height];
                Inflater.Read(bitmap);
                scx.bitmap.bitmap = bitmap;
            }
            else
            {
                scx.bitmap.bitmap = new byte[0];
            }

            //behavior names
            Inflater.Read(new byte[SCX.PLAYER_MAX_16 * (SCX.BEHAVIOR_COUNT - 1) * 2]); // SKIP ALL AOE1 PROPS
                                                                                       //for (int i=0; i<3; ++i){
            for (int j = 0; j < SCX.PLAYER_MAX_16; ++j)
            {
                Inflater.Read(byte2);
                int length = ByteConverter.getShort(byte2, 0);

                if (length > 0)
                {
                    byte[] message = new byte[length];
                    Inflater.Read(message);
                    scx.players[j].ai = Encoding.UTF8.GetString(message);
                }
            }

            //behavior size & data
            for (int i = 0; i < SCX.PLAYER_MAX_16; ++i)
            {
                int[] lengths = new int[SCX.BEHAVIOR_COUNT];

                for (int j = 0; j < SCX.BEHAVIOR_COUNT; ++j)
                {
                    lengths[j] = 0;
                    Inflater.Read(byte4);
                }
                for (int j = 0; j < SCX.BEHAVIOR_COUNT; ++j)
                {
                    byte[] message = new byte[lengths[j]];
                    Inflater.Read(message);
                    scx.players[i].aic[j] = Encoding.UTF8.GetString(message);
                }
            }

            //behavior type
            Inflater.Read(byte16);

            for (int i = 0; i < SCX.PLAYER_MAX_16; ++i)
            {
                scx.players[i].aitype = (char)byte16[i];
            }

            //separator 1
            Inflater.Read(byte4);

            //player config 2
            Inflater.Read(new byte[24 * SCX.PLAYER_MAX_16]);

            //separator 2
            Inflater.Read(byte4);

            //victory / globals
            //# 0x01 = conquest
            //# 0x02 = ruins
            //# 0x03 = artifacts
            //# 0x04 = discoveries
            //# 0x05 = explored
            //# 0x06 = gold count
            //# 0x07 = required
            //# 0x08 = condition
            //# 0x09 = score
            //# 0x0A = time limit
            for (int i = 0; i < SCX.VICTORY_CONDITION_COUNT; ++i)
            {
                scx.victories[i] = 0;
                Inflater.Read(byte4);
            }

            //victory / diplomacy / player / stance
            for (int i = 0; i < SCX.PLAYER_MAX_16; ++i)
            {
                for (int j = 0; j < SCX.PLAYER_MAX_16; ++j)
                {
                    scx.players[i].v_diplomacies[j] = 0;
                    Inflater.Read(byte4);
                }
            }

            //victory / individual-victory (12 triggers per players)
            //(they are unused in AoK/AoC once the new trigger system was introduced)
            Inflater.Read(new byte[SCX.PLAYER_MAX_16 * 15 * 12 * 4]);

            //separator  3
            Inflater.Read(byte4);

            //victory / diplomacy / player / allied
            for (int i = 0; i < SCX.PLAYER_MAX_16; ++i)
            {
                scx.players[i].alliedvictory = 0;
                Inflater.Read(byte4);
            }

            //disability / techtree
            int[] disables = { SCX.DISABLED_TECH_COUNT, SCX.DISABLED_UNIT_COUNT, SCX.DISABLED_BUILDING_COUNT };
            for (int i = 0; i < 3; ++i)
            {
                Inflater.Read(new byte[64]);

                for (int j = 0; j < SCX.PLAYER_MAX_16; ++j)
                {
                    for (int k = 0; k < disables[i]; ++k)
                    {
                        Inflater.Read(byte4);
                        switch (i)
                        {
                        case 0: scx.players[j].disabled_techs[k] = 0; break;

                        case 1: scx.players[j].disabled_units[k] = 0; break;

                        case 2: scx.players[j].disabled_buildings[k] = 0; break;
                        }
                    }
                }
            }

            //disability / options
            for (int i = 0; i < 3; ++i)
            {
                Inflater.Read(byte4);
                scx.disability_options[i] = 0;
            }

            //disability / starting age
            for (int i = 0; i < SCX.PLAYER_MAX_16; ++i)
            {
                //Starting age is determined by the first byte. 0 = dark, 1 = feudal, 2=castle, 3=imp, 4 = post-imp.
                //The other 3 byte appear to no importance other than buffer data.
                //byte[] newByte4 = new byte[] { (byte)0, (byte)0, (byte)0, (byte)0 };
                scx.players[i].startage = 0;
                Inflater.Read(byte4);
            }

            //separator  4
            Inflater.Read(byte4);

            //terrain / view
            Inflater.Read(byte4);
            Inflater.Read(byte4);

            //terrain / type
            Inflater.Read(byte4);

            //terrain size
            scx.terrain.sizex = 0;
            Inflater.Read(byte4);
            scx.terrain.sizey = 0;
            Inflater.Read(byte4);

            //terrain data @TERRAIN
            byte[] byte3 = new byte[3];
            scx.terrain.InitializeTiles();
            for (int i = 0; i < scx.terrain.sizey; ++i)
            {
                for (int j = 0; j < scx.terrain.sizex; ++j)
                {
                    Inflater.Read(byte3);
                    scx.terrain.tiles[j, i] = (char)byte3[0];
                    scx.terrain.hills[j, i] = (char)byte3[1];
                }
            }

            //players count 2
            // GAIA included
            Inflater.Read(byte4);
            scx.player_count[1] = 0;

            //player sources & config
            //The original version had a loop here that looped through playercount
            //and set all the resources. However, playercount was hard-coded to 0, so I removed the loop.

            //objects: players
            //The original version had a loop here that looped through playercount
            //However, playercount was hard-coded to 0, so I removed the loop.

            //players count 3: Should be 9
            scx.player_count[2] = 0;
            Inflater.Read(byte4);

            Inflater.Close();

            return(scx);
        }
        private void LoadLayerDataBase64(XmlHelper xmlHelper, Layer layer, string dataCompression)
        {
            xmlHelper.AdvanceNode(XmlNodeType.Text);

            string base64Data = xmlHelper.XmlReader.Value;

            byte[] dataBytes = System.Convert.FromBase64String(base64Data);

            if (dataCompression == "none")
            {
                // do nothing
            }
            else if (dataCompression == "gzip")
            {
                GZipStream inGZipStream = new GZipStream(
                    new MemoryStream(dataBytes), CompressionMode.Decompress);

                MemoryStream outMemoryStream = new MemoryStream();

                byte[] buffer = new byte[1024];
                while (true)
                {
                    int bytesRead = inGZipStream.Read(buffer, 0, buffer.Length);
                    if (bytesRead == 0)
                    {
                        break;
                    }
                    outMemoryStream.Write(buffer, 0, bytesRead);
                }

                dataBytes = outMemoryStream.ToArray();
            }
            else if (dataCompression == "zlib")
            {
                ZInputStream inZInputStream = new ZInputStream(
                    new MemoryStream(dataBytes));

                MemoryStream outMemoryStream = new MemoryStream();

                byte[] buffer = new byte[1024];
                while (true)
                {
                    int bytesRead = inZInputStream.Read(buffer, 0, buffer.Length);
                    if (bytesRead == 0)
                    {
                        break;
                    }
                    outMemoryStream.Write(buffer, 0, bytesRead);
                }

                dataBytes = outMemoryStream.ToArray();
            }
            else
            {
                throw new Exception("Unknown compression scheme: " + dataCompression);
            }

            if (dataBytes.Length % 4 != 0)
            {
                throw new Exception("Base64 byte stream size must be a mutliple of 4 bytes");
            }

            Location tileLocation = Location.Origin;

            for (int byteIndex = 0; byteIndex < dataBytes.Length; byteIndex += 4)
            {
                int gid =
                    dataBytes[byteIndex] |
                    dataBytes[byteIndex + 1] << 8 |
                        dataBytes[byteIndex + 2] << 16 |
                        dataBytes[byteIndex + 3] << 24;

                layer.Tiles[tileLocation] = LoadStaticTile(layer, gid);

                ++tileLocation.X;
                if (tileLocation.X >= layer.LayerWidth)
                {
                    tileLocation.X = 0;
                    ++tileLocation.Y;
                }
            }

            xmlHelper.AdvanceEndElement("data");
        }
Esempio n. 18
0
        public void endElement(object ctx, string elementName)
        {
            CCTMXMapInfo pTMXMapInfo = this;

            byte[] buffer = pTMXMapInfo.CurrentString;

            if (elementName == "data" && (pTMXMapInfo.LayerAttribs & (int)TMXLayerAttrib.TMXLayerAttribBase64) != 0)
            {
                pTMXMapInfo.StoringCharacters = false;
                CCTMXLayerInfo layer = pTMXMapInfo.Layers.LastOrDefault();
                if ((pTMXMapInfo.LayerAttribs & ((int)(TMXLayerAttrib.TMXLayerAttribGzip) | (int)TMXLayerAttrib.TMXLayerAttribZlib)) != 0)
                {
                    using (MemoryStream ms = new MemoryStream(buffer, false))
                    {
                        //gzip compress
                        if ((pTMXMapInfo.LayerAttribs & (int)TMXLayerAttrib.TMXLayerAttribGzip) != 0)
                        {
                            using (GZipInputStream inStream = new GZipInputStream(ms))
                            {
                                using (var br = new BinaryReader(inStream))
                                {
                                    for (int i = 0; i < layer.m_pTiles.Length; i++)
                                    {
                                        layer.m_pTiles[i] = br.ReadInt32();
                                    }
                                }
                            }
                        }

                        //zlib
                        if ((pTMXMapInfo.LayerAttribs & (int)TMXLayerAttrib.TMXLayerAttribZlib) != 0)
                        {
                            using (ZInputStream inZStream = new ZInputStream(ms))
                            {
                                for (int i = 0; i < layer.m_pTiles.Length; i++)
                                {
                                    layer.m_pTiles[i] = inZStream.Read();
                                    inZStream.Read();
                                    inZStream.Read();
                                    inZStream.Read();
                                }
                            }
                        }
                    }
                }
                else
                {
                    for (int i = 0; i < layer.m_pTiles.Length; i++)
                    {
                        layer.m_pTiles[i] = buffer[i * 4];
                    }
                }

                pTMXMapInfo.CurrentString = null;
            }
            else if (elementName == "map")
            {
                // The map element has ended
                pTMXMapInfo.ParentElement = (int)TMXProperty.TMXPropertyNone;
            }
            else if (elementName == "layer")
            {
                // The layer element has ended
                pTMXMapInfo.ParentElement = (int)TMXProperty.TMXPropertyNone;
            }
            else if (elementName == "objectgroup")
            {
                // The objectgroup element has ended
                pTMXMapInfo.ParentElement = (int)TMXProperty.TMXPropertyNone;
            }
            else if (elementName == "object")
            {
                // The object element has ended
                pTMXMapInfo.ParentElement = (int)TMXProperty.TMXPropertyNone;
            }
        }