System.IO.BinaryReader.ReadInt32()

Here are the examples of the csharp api System.IO.BinaryReader.ReadInt32() taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

2902 Examples 7

19 Source : CoumpundDocumentItem.cs
with Apache License 2.0
from Appdynamics

internal void Read(BinaryReader br)
        {
            var s = br.ReadBytes(0x40);
            var sz = br.ReadInt16();
            if (sz > 0)
            {
                Name = UTF8Encoding.Unicode.GetString(s, 0, sz - 2);
            }
            ObjectType = br.ReadByte();
            ColorFlag = br.ReadByte();
            LeftSibling = br.ReadInt32();
            RightSibling = br.ReadInt32();
            ChildID = br.ReadInt32();

            //Clsid;
            ClsID = new Guid(br.ReadBytes(16));

            StatBits = br.ReadInt32();
            CreationTime = br.ReadInt64();
            ModifiedTime = br.ReadInt64();

            StartingSectorLocation = br.ReadInt32();
            StreamSize = br.ReadInt64();
        }

19 Source : CompoundDocumentFile.cs
with Apache License 2.0
from Appdynamics

private void LoadDIFATSectors(DocWriteInfo dwi)
        {
            var nextSector = _firstDIFATSectorLocation;
            while (nextSector > 0)
            {
                var brDI = new BinaryReader(new MemoryStream(_sectors[nextSector]));
                var sect = -1;
                while (brDI.BaseStream.Position < _sectorSize)
                {
                    if (sect > 0)
                    {
                        dwi.DIFAT.Add(sect);
                    }
                    sect = brDI.ReadInt32();
                }
                nextSector = sect;
            }
        }

19 Source : CompoundDocumentFile.cs
with Apache License 2.0
from Appdynamics

private List<int> ReadMiniFAT(List<byte[]> sectors, DocWriteInfo dwi)
        {
            var l = new List<int>();
            var nextSector = _firstMiniFATSectorLocation;
            while(nextSector!=END_OF_CHAIN)
            {
                var br = new BinaryReader(new MemoryStream(sectors[nextSector]));
                while (br.BaseStream.Position < _sectorSize)
                {
                    var d = br.ReadInt32();
                    l.Add(d);
                }
                nextSector = dwi.FAT[nextSector];
            }
            return l;
        }

19 Source : CompoundDocumentFile.cs
with Apache License 2.0
from Appdynamics

private List<int> ReadFAT(List<byte[]> sectors, DocWriteInfo dwi)
        {
            var l = new List<int>();
            foreach (var i in dwi.DIFAT)
            {
                var br = new BinaryReader(new MemoryStream(sectors[i]));
                while (br.BaseStream.Position < _sectorSize)
                {
                    var d = br.ReadInt32();
                    l.Add(d);
                }
            }
            return l;
        }

19 Source : WaveFile.cs
with MIT License
from ar1st0crat

protected void ReadWaveStream(Stream waveStream, bool normalized = true)
        {
            using (var reader = new BinaryReader(waveStream, Encoding.ASCII, true))
            {
                if (reader.ReadInt32() != 0x46464952)     // "RIFF"
                {
                    throw new FormatException("WAV data error: NOT RIFF!");
                }

                // ignore file size
                reader.ReadInt32();

                if (reader.ReadInt32() != 0x45564157)     // "WAVE"
                {
                    throw new FormatException("WAV data error: NOT WAVE!");
                }

                // try to find "fmt " header in the file:

                var fmtPosition = reader.BaseStream.Position;
                while (fmtPosition != reader.BaseStream.Length - 1)
                {
                    reader.BaseStream.Position = fmtPosition;
                    var fmtId = reader.ReadInt32();
                    if (fmtId == 0x20746D66)
                    {
                        break;
                    }
                    fmtPosition++;
                }

                if (fmtPosition == reader.BaseStream.Length - 1)
                {
                    throw new FormatException("WAV data error: NOT fmt !");
                }

                var fmtSize = reader.ReadInt32();

                WaveFormat waveFmt;
                waveFmt.AudioFormat = reader.ReadInt16();
                waveFmt.ChannelCount = reader.ReadInt16();
                waveFmt.SamplingRate = reader.ReadInt32();
                waveFmt.ByteRate = reader.ReadInt32();
                waveFmt.Align = reader.ReadInt16();
                waveFmt.BitsPerSample = reader.ReadInt16();

                WaveFmt = waveFmt;

                if (fmtSize == 18)
                {
                    var fmtExtraSize = reader.ReadInt16();
                    reader.ReadBytes(fmtExtraSize);
                }

                // there may be some wavefile meta info here,
                // so try to find "data" header in the file:

                var dataPosition = reader.BaseStream.Position;
                while (dataPosition != reader.BaseStream.Length - 1)
                {
                    reader.BaseStream.Position = dataPosition;
                    var dataId = reader.ReadInt32();
                    if (dataId == 0x61746164)
                    {
                        break;
                    }
                    dataPosition++;
                }

                if (dataPosition == reader.BaseStream.Length - 1)
                {
                    throw new FormatException("WAV data error: NOT data!");
                }

                var length = reader.ReadInt32();

                length /= waveFmt.ChannelCount;
                length /= (waveFmt.BitsPerSample / 8);

                Signals = new List<DiscreteSignal>();

                for (var i = 0; i < waveFmt.ChannelCount; i++)
                {
                    Signals.Add(new DiscreteSignal(waveFmt.SamplingRate, length));
                }

                switch (waveFmt.BitsPerSample)
                {
                    case 8:
                        {
                            for (var i = 0; i < length; i++)
                            {
                                for (var j = 0; j < waveFmt.ChannelCount; j++)
                                {
                                    Signals[j][i] = reader.ReadByte() - 128;
                                    if (normalized) Signals[j][i] /= 128;
                                }
                            }
                            break;
                        }

                    case 16:
                        {
                            for (var i = 0; i < length; i++)
                            {
                                for (var j = 0; j < waveFmt.ChannelCount; j++)
                                {
                                    Signals[j][i] = reader.ReadInt16();
                                    if (normalized) Signals[j][i] /= 32768;
                                }
                            }
                            break;
                        }

                    case 32:
                        {
                            if (waveFmt.AudioFormat == 1)
                            {
                                for (var i = 0; i < length; i++)
                                {
                                    for (var j = 0; j < waveFmt.ChannelCount; j++)
                                    {
                                        Signals[j][i] = reader.ReadInt32();
                                        if (normalized) Signals[j][i] /= 2147483648;
                                    }
                                }
                            }
                            else if (waveFmt.AudioFormat == 3)/*IeeeFloat*/
                            {
                                for (var i = 0; i < length; i++)
                                {
                                    for (var j = 0; j < waveFmt.ChannelCount; j++)
                                    {
                                        Signals[j][i] = reader.ReadSingle();
                                    }
                                }
                            }
                            break;
                        }

                    case 24:
                        {
                            for (var i = 0; i < length; i++)
                            {
                                for (var j = 0; j < waveFmt.ChannelCount; j++)
                                {
                                    var b1 = reader.ReadByte();
                                    var b2 = reader.ReadByte();
                                    var b3 = reader.ReadByte();

                                    Signals[j][i] = (b1 << 8 | b2 << 16 | b3 << 24);
                                    if (normalized) Signals[j][i] /= 2147483648;
                                }
                            }
                            break;
                        }

                    default:
                        throw new ArgumentException(
                            "Wrong bit depth! Supported values are: " + string.Join(", ", SupportedBitDepths));
                }
            }
        }

19 Source : Signal.cs
with MIT License
from ar1st0crat

public void Load(Stream waveStream)
        {
            using (var reader = new BinaryReader(waveStream))
            {
                if (reader.ReadInt32() != 0x46464952)     // "RIFF"
                {
                    throw new FormatException("NOT RIFF!");
                }

                // ignore file size
                reader.ReadInt32();

                if (reader.ReadInt32() != 0x45564157)     // "WAVE"
                {
                    throw new FormatException("NOT WAVE!");
                }

                // try to find "fmt " header in the file:

                var fmtPosition = reader.BaseStream.Position;
                while (fmtPosition != reader.BaseStream.Length - 1)
                {
                    reader.BaseStream.Position = fmtPosition;
                    var fmtId = reader.ReadInt32();
                    if (fmtId == 0x20746D66)
                    {
                        break;
                    }
                    fmtPosition++;
                }

                if (fmtPosition == reader.BaseStream.Length - 1)
                {
                    throw new FormatException("NOT fmt !");
                }

                var fmtSize = reader.ReadInt32();

                SignalType = reader.ReadInt16();
                Channels = reader.ReadInt16();
                Freq = reader.ReadInt32();
                AverageBytesPerSecond = reader.ReadInt32();
                Align = reader.ReadInt16();
                BitsPerSample = reader.ReadInt16();

                if (fmtSize == 18)
                {
                    var fmtExtraSize = reader.ReadInt16();
                    reader.ReadBytes(fmtExtraSize);
                }
                
                if (reader.ReadInt32() != 0x61746164)      // "data"
                {
                    throw new FormatException("NOT data!");
                }

                Length = reader.ReadInt32();

                Length /= Channels;
                Length /= (BitsPerSample / 8);

                _samples = new double[Channels][];
                for (var i = 0; i < Channels; i++)
                {
                    _samples[i] = new double[Length];
                }
                
                if (BitsPerSample == 8)
                {
                    for (var i = 0; i < Length; i++)
                    {
                        for (var j = 0; j < Channels; j++)
                        {
                            _samples[j][i] = (reader.ReadByte() - 128) / 256.0;
                        }
                    }
                }
                else
                {
                    for (var i = 0; i < Length; i++)
                    {
                        for (var j = 0; j < Channels; j++)
                        {
                            _samples[j][i] = reader.ReadInt16() / (double)short.MaxValue;
                        }
                    }
                }
            }
        }

19 Source : AgeDisassembler.cs
with MIT License
from arcusmaximus

public void Disreplacedemble()
        {
            _stream.Position = 0x28;
            StringTableOffset = ArrayTableOffset = LabelTableOffset = AddressToOffset(_reader.ReadInt32());

            _stream.Position = 0x3C;
            while (_stream.Position < StringTableOffset)
            {
                Read();
            }
        }

19 Source : AgeDisassembler.cs
with MIT License
from arcusmaximus

private void Read()
        {
            int opcode = _reader.ReadInt32();
            int numOperands = NumOperands[opcode];
            for (int i = 0; i < numOperands; i++)
            {
                int type = _reader.ReadInt32();
                int value = _reader.ReadInt32();
                if (type == 2)
                    HandleStringOperand((int)_stream.Position - 4, value);
                else if (opcode == 0x64 && i == 1)
                    HandleArrayOperand((int)_stream.Position - 4, value);
            }
        }

19 Source : AgeDisassembler.cs
with MIT License
from arcusmaximus

private void HandleArrayOperand(int offset, int address)
        {
            ArrayAddressEncountered?.Invoke(offset);

            int originalPos = (int)_stream.Position;

            int startPos = AddressToOffset(address);
            _stream.Position = startPos;
            int numItems = _reader.ReadInt32();

            ArrayEncountered?.Invoke(new Range(startPos, 4 + numItems * 4, ScriptStringType.CharacterName));

            _stream.Position = originalPos;

            StringTableOffset = Math.Min(StringTableOffset, startPos);
            ArrayTableOffset = Math.Min(ArrayTableOffset, startPos);
        }

19 Source : EthornellDisassembler.cs
with MIT License
from arcusmaximus

private void ReadInt32Operand()
        {
            _reader.ReadInt32();
        }

19 Source : EthornellDisassembler.cs
with MIT License
from arcusmaximus

protected void ReadCodeAddress()
        {
            int offset = (int)_reader.BaseStream.Position;
            int address = _reader.ReadInt32();
            OnCodeAddressEncountered(offset, address);
        }

19 Source : EthornellDisassembler.cs
with MIT License
from arcusmaximus

protected void ReadStringAddress(ScriptStringType type)
        {
            int offset = (int)_reader.BaseStream.Position;
            int address = _reader.ReadInt32();
            OnStringAddressEncountered(offset, address, type);
        }

19 Source : PropellerV1Disassembler.cs
with MIT License
from arcusmaximus

private void ReadLabelList()
        {
            int listSize = _reader.ReadInt32();
            if (listSize % 9 != 0)
                throw new InvalidDataException("Label list size must be a multiple of 9");

            int listEndOffset = (int)_stream.Position + listSize;
            while (_stream.Position < listEndOffset)
            {
                byte marker = _reader.ReadByte();
                if (marker != 0)
                    throw new InvalidDataException("Label marker must be 0");

                int labelNumber = _reader.ReadInt32();
                AddressEncountered?.Invoke((int)_stream.Position);
                int labelAddress = _reader.ReadInt32();
            }
        }

19 Source : PropellerV1Disassembler.cs
with MIT License
from arcusmaximus

private void ReadInstruction()
        {
            byte opcodeHigh = _reader.ReadByte();
            byte opcodeLow = _reader.ReadByte();
            short opcode = (short)((opcodeHigh << 8) | opcodeLow);

            if (!OperandTemplates.TryGetValue(opcode, out string operandTypes))
                throw new InvalidDataException($"Unsupported opcode {opcode:X04} encountered");

            object[] operands = new object[operandTypes.Length];
            for (int i = 0; i < operandTypes.Length; i++)
            {
                operands[i] = operandTypes[i] switch
                              {
                                  'b' => _reader.ReadByte(),
                                  'h' => _reader.ReadInt16(),
                                  'i' => _reader.ReadInt32(),
                                  's' => ReadStringRange()
                              };
            }

19 Source : RealLiveDisassembler.cs
with MIT License
from arcusmaximus

private void ReadKidokuFlag()
        {
            int lineNumberIndex = _reader.ReadUInt16();
            int pos = (int)_stream.Position;

            _stream.Position = _lineNumbersOffset + 4 * lineNumberIndex;
            int lineNumber = _reader.ReadInt32() - 1000000;
            if (lineNumber >= 0)
            {
                int entryPointOffset = 0x34 + lineNumber * 4;
                AddressEncountered?.Invoke(entryPointOffset);
            }

            _stream.Position = pos;
        }

19 Source : RealLiveDisassembler.cs
with MIT License
from arcusmaximus

private void ReadExpression()
        {
            byte variable = _reader.ReadByte();
            if (variable == 0xC8)
                return;

            if (variable == 0xFF)
            {
                _reader.ReadInt32();
                return;
            }

            ReadItemList('[', ']');
        }

19 Source : RealLiveDisassembler.cs
with MIT License
from arcusmaximus

private void ReadOffset()
        {
            AddressEncountered?.Invoke((int)_stream.Position);
            _reader.ReadInt32();
        }

19 Source : YurisAttribute.cs
with MIT License
from arcusmaximus

public void Read(BinaryReader reader, int valuesOffset)
        {
            DescriptorOffset = (int)reader.BaseStream.Position;
            Id = reader.ReadInt16();
            Type = (YurisAttributeType)reader.ReadInt16();
            ValueLength = reader.ReadInt32();
            ValueOffset = valuesOffset + reader.ReadInt32();
        }

19 Source : YurisScript.cs
with MIT License
from arcusmaximus

public void Load(ScriptLocation location)
        {
            LoadCommandListForScript(location);
            _script = File.ReadAllBytes(location.ToFilePath());

            MemoryStream stream = new MemoryStream(_script);
            BinaryReader reader = new BinaryReader(stream);
            int magic = reader.ReadInt32();
            if (magic != 0x42545359)
            {
                _script = null;
                return;
            }

            int version = reader.ReadInt32();
            int numInstructions = reader.ReadInt32();
            _instructionsSize = reader.ReadInt32();
            if (_instructionsSize != numInstructions * 4)
                throw new InvalidDataException();

            _attributeDescriptorsSize = reader.ReadInt32();
            _attributeValuesSize = reader.ReadInt32();
            _lineNumbersSize = reader.ReadInt32();
            reader.ReadInt32();

            _instructionsOffset = (int)stream.Position;
            _attributeDescriptorsOffset = _instructionsOffset + _instructionsSize;
            _attributeValuesOffset = _attributeDescriptorsOffset + _attributeDescriptorsSize;
            _lineNumbersOffset = _attributeValuesOffset + _attributeValuesSize;
            if (_lineNumbersOffset + _lineNumbersSize != _script.Length)
                throw new InvalidDataException();

            if (_attributeDescriptorsSize > 0)
                _key = BitConverter.ToUInt32(_script, _attributeDescriptorsOffset + 8);

            ToggleScriptEncryption(_script, _key);
        }

19 Source : BinaryPatcher.cs
with MIT License
from arcusmaximus

public void PatchAddress(int originalOffset)
        {
            if (originalOffset < 0 || originalOffset + 4 > _inputStream.Length)
                throw new ArgumentOutOfRangeException(nameof(originalOffset));

            if (_inputStream.Position < originalOffset + 4)
                throw new InvalidOperationException();

            int inputPos = (int)_inputStream.Position;
            _inputStream.Position = originalOffset;
            int originalAddr = _reader.ReadInt32();
            _inputStream.Position = inputPos;

            int newOffset = MapOffset(originalOffset);
            int newAddr = _offsetToAddress(MapOffset(_addressToOffset(originalAddr)));

            _outputStream.Position = newOffset;
            _writer.Write(newAddr);
            _outputStream.Position = _outputStream.Length;
        }

19 Source : IoExtensions.cs
with MIT License
from arcusmaximus

public static byte[] ReadByteArray(this BinaryReader reader)
        {
            int count = reader.ReadInt32();
            return reader.ReadBytes(count);
        }

19 Source : IoExtensions.cs
with MIT License
from arcusmaximus

public static int[] ReadInt32Array(this BinaryReader reader)
        {
            return reader.ReadArray(r => r.ReadInt32());
        }

19 Source : IoExtensions.cs
with MIT License
from arcusmaximus

public static string ReadCharArrayreplacedtring(this BinaryReader reader)
        {
            int count = reader.ReadInt32();
            char[] chars = reader.ReadChars(count);
            return new string(chars);
        }

19 Source : IoExtensions.cs
with MIT License
from arcusmaximus

public static T[] ReadArray<T>(this BinaryReader reader, Func<BinaryReader, T> readItem)
        {
            int count = reader.ReadInt32();
            T[] result = new T[count];
            for (int i = 0; i < count; i++)
            {
                result[i] = readItem(reader);
            }

            return result;
        }

19 Source : TjsScript.cs
with MIT License
from arcusmaximus

public void Load(ScriptLocation location)
        {
            using (Stream stream = File.OpenRead(location.ToFilePath()))
            using (BinaryReader reader = new BinaryReader(stream, Encoding.Unicode))
            {
                byte[] magic = reader.ReadBytes(8);
                if (!magic.SequenceEqual(Magic))
                    throw new InvalidDataException("Invalid magic");

                int fileSize = reader.ReadInt32();
                if (fileSize != stream.Length)
                    throw new InvalidDataException("Invalid file size");

                byte[] dataTag = reader.ReadBytes(4);
                if (!dataTag.SequenceEqual(DataTag))
                    throw new InvalidDataException("Invalid DATA tag");

                int dataSectionSize = reader.ReadInt32();
                ReadConstantArrays(reader);
                if (dataSectionSize != stream.Position - (Magic.Length + 4))
                    throw new InvalidDataException("Invalid DATA size");

                _fileRemainder = reader.ReadBytes((int)(reader.BaseStream.Length - reader.BaseStream.Position));
            }
        }

19 Source : CatSystemScript.cs
with MIT License
from arcusmaximus

private static byte[] Decompress(byte[] inputData)
        {
            MemoryStream inputStream = new MemoryStream(inputData);
            BinaryReader reader = new BinaryReader(inputStream);
            byte[] magic = reader.ReadBytes(8);
            if (!magic.SequenceEqual(Magic))
                throw new InvalidDataException("Invalid magic");

            int compressedLength = reader.ReadInt32();
            int uncompressedLength = reader.ReadInt32();
            if (compressedLength == 0)
            {
                if (uncompressedLength != inputStream.Length - 0x10)
                    throw new InvalidDataException("Invalid size");

                return reader.ReadBytes(uncompressedLength);
            }
            else
            {
                if (compressedLength != inputStream.Length - 0x10)
                    throw new InvalidDataException("Invalid compressed size");

                ushort zlibHeader = reader.ReadUInt16();
                byte[] uncompressedData = new byte[uncompressedLength];
                using (DeflateStream decompressionStream = new DeflateStream(inputStream, CompressionMode.Decompress))
                {
                    decompressionStream.Read(uncompressedData, 0, uncompressedData.Length);
                }
                return uncompressedData;
            }
        }

19 Source : Card_Manager.cs
with MIT License
from Arefu

private void LoadRelatedCards(IReadOnlyList<Card_Info> cards,
            IReadOnlyDictionary<short, Card_Info> cardsByCardId, IList<Card_Tag_Info> tags,
            IReadOnlyDictionary<Localized_Text.Language, byte[]> taginfos)
        {
            foreach (Localized_Text.Language language in Enum.GetValues(typeof(Localized_Text.Language)))
            {
                if (language == Localized_Text.Language.Unknown) continue;

                using (var reader = new BinaryReader(new MemoryStream(taginfos[language])))
                {
                    var count = reader.ReadInt32();
                    for (var i = 0; i < count; i++)
                    {
                        Card_Tag_Info tagInfo = null;
                        if (i >= tags.Count)
                        {
                            tagInfo = new Card_Tag_Info();
                            tags.Add(tagInfo);
                        }
                        else
                        {
                            tagInfo = tags[i];
                        }

                        tagInfo.Index = i;
                        tagInfo.MainType = (Card_Tag_Info.Type) reader.ReadInt16();
                        tagInfo.MainValue = reader.ReadInt16();
                        for (var j = 0; j < tagInfo.Elements.Length; j++)
                        {
                            tagInfo.Elements[j].Type = (Card_Tag_Info.ElementType) reader.ReadInt16();
                            tagInfo.Elements[j].Value = reader.ReadInt16();
                        }

                        var stringOffset1 = reader.ReadInt64();
                        var stringOffset2 = reader.ReadInt64();

                        var tempOffset = reader.BaseStream.Position;

                        reader.BaseStream.Position = stringOffset1;
                        tagInfo.Text.SetText(language, reader.ReadNullTerminatedString(Encoding.Unicode));

                        reader.BaseStream.Position = stringOffset2;
                        tagInfo.DisplayText.SetText(language, reader.ReadNullTerminatedString(Encoding.Unicode));

                        reader.BaseStream.Position = tempOffset;
                    }
                }
            }

            using (var reader =
                new BinaryReader(new MemoryStream(Manager.Archive.Root.FindFile("bin/tagdata.bin").LoadBuffer())))
            {
                var dataStart = reader.BaseStream.Position + cards.Count * 8;

                for (var i = 0; i < cards.Count; i++)
                {
                    var shortoffset = reader.ReadUInt32();
                    var tagCount = reader.ReadUInt32();

                    var tempOffset = reader.BaseStream.Position;

                    var start = dataStart + shortoffset * 4;
                    reader.BaseStream.Position = start;
                    if (tagCount > 0 && i >= 0)
                    {
                        var card = cards[i];
                        card.RelatedCards.Clear();
                        for (var j = 0; j < tagCount; j++)
                            card.RelatedCards.Add(new RelatedCardInfo(cardsByCardId[reader.ReadInt16()],
                                Tags[reader.ReadInt16()]));
                    }

                    reader.BaseStream.Position = tempOffset;
                }
            }

            var knownMainTagTypes = (Card_Tag_Info.Type[]) Enum.GetValues(typeof(Card_Tag_Info.Type));
            var knownElementTagTypes = (Card_Tag_Info.ElementType[]) Enum.GetValues(typeof(Card_Tag_Info.ElementType));
            foreach (var tag in tags)
            {
                Debug.replacedert(knownMainTagTypes.Contains(tag.MainType));
                Debug.replacedert(tag.MainValue <= 1);

                foreach (var element in tag.Elements)
                {
                    if (element.Type == Card_Tag_Info.ElementType.None) continue;

                    Debug.replacedert(knownElementTagTypes.Contains(element.Type));
                }

                if (tag.MainType == Card_Tag_Info.Type.Exact)
                {
                    // Need english here
                    var language = Localized_Text.Language.English;
                    var displayText = tag.DisplayText.GetText(language);
                    var text = tag.Text.GetText(Localized_Text.Language.English);
                    var splitIndex = displayText == null ? -1 : displayText.IndexOf(':');
                    if (splitIndex >= 0)
                    {
                        var typeStr = displayText.Substring(0, splitIndex).Trim();
                        var value = displayText.Substring(splitIndex + 1).Trim();
                        switch (typeStr.ToLower())
                        {
                            case "related to":
                                tag.Exact = Card_Tag_Info.ExactType.RelatedTo;
                                tag.ExactCard = FindCardByName(language, value);
                                break;
                            case "card effect":
                                tag.Exact = Card_Tag_Info.ExactType.CardEffect;
                                break;
                            case "ritual monster":
                                tag.Exact = Card_Tag_Info.ExactType.RitualMonster;
                                tag.ExactCard = FindCardByName(language, value);
                                break;
                            case "fusion monster":
                                tag.Exact = Card_Tag_Info.ExactType.FusionMonster;
                                tag.ExactCard = FindCardByName(language, value);
                                break;
                            case "spell and trap":
                                tag.Exact = Card_Tag_Info.ExactType.SpellTrap;
                                break;
                            case "works well with":
                                tag.Exact = Card_Tag_Info.ExactType.WorksWellWith;
                                tag.ExactCard = FindCardByName(language, value);
                                break;
                            default:
                                Debug.replacedert(false);
                                break;
                        }
                    }
                    else
                    {
                        switch (text.ToLower())
                        {
                            case "banishbeast":
                                tag.Exact = Card_Tag_Info.ExactType.BanishBeast;
                                break;
                            case "banishdark":
                                tag.Exact = Card_Tag_Info.ExactType.BanishDark;
                                break;
                            case "banishfish":
                                tag.Exact = Card_Tag_Info.ExactType.BanishFish;
                                break;
                            case "banishrock":
                                tag.Exact = Card_Tag_Info.ExactType.BanishRock;
                                break;
                            case "countertrapfairy":
                                tag.Exact = Card_Tag_Info.ExactType.CounterTrapFairy;
                                break;
                            case "spellcounter":
                                tag.Exact = Card_Tag_Info.ExactType.SpellCounter;
                                break;
                            default:
                                Debug.replacedert(false);
                                break;
                        }
                    }

                    switch (tag.Exact)
                    {
                        case Card_Tag_Info.ExactType.CardEffect:
                            Card_Tag_Info.CardEffectType cardEffect;
                            if (!Enum.TryParse(text, true, out cardEffect)) Debug.replacedert(false);
                            tag.CardEffect = cardEffect;
                            break;

                        case Card_Tag_Info.ExactType.SpellTrap:
                            Card_Tag_Info.CardEffectType spellEffect;
                            if (!Enum.TryParse("Spell_" + text, true, out spellEffect)) Debug.replacedert(false);
                            tag.CardEffect = spellEffect;
                            break;
                    }
                }
            }

            foreach (var card in cards)
            foreach (var relatedCardInfo in card.RelatedCards)
                if (relatedCardInfo.TagInfo.CardEffect != Card_Tag_Info.CardEffectType.None)
                    card.CardEffectTags.Add(relatedCardInfo.TagInfo.CardEffect);
        }

19 Source : Char_Data.cs
with MIT License
from Arefu

public override void Load(BinaryReader reader, long length, Localized_Text.Language language)
        {
            var fileStartPos = reader.BaseStream.Position;

            var count = (uint) reader.ReadUInt64();
            for (uint i = 0; i < count; i++)
            {
                var id = reader.ReadInt32();
                var series = (Duel_Series) reader.ReadInt32();
                var challengeDeckId = reader.ReadInt32();
                var unk3 = reader.ReadInt32();
                var dlcId = reader.ReadInt32();
                var unk5 = reader.ReadInt32();
                var type = reader.ReadInt64();
                var keyOffset = reader.ReadInt64();
                var valueOffset = reader.ReadInt64();
                var descriptionOffset = reader.ReadInt64();

                var tempOffset = reader.BaseStream.Position;

                reader.BaseStream.Position = fileStartPos + keyOffset;
                var codeName = reader.ReadNullTerminatedString(keyEncoding);

                reader.BaseStream.Position = fileStartPos + valueOffset;
                var name = reader.ReadNullTerminatedString(valueEncoding);

                reader.BaseStream.Position = fileStartPos + descriptionOffset;
                var bio = reader.ReadNullTerminatedString(valueEncoding);

                reader.BaseStream.Position = tempOffset;

                if (!Items.TryGetValue(id, out var item))
                {
                    item = new Item(id, series, challengeDeckId, unk3, dlcId, unk5, type);
                    Items.Add(item.Id, item);
                }

                item.CodeName.SetText(language, codeName);
                item.Name.SetText(language, name);
                item.Bio.SetText(language, bio);
            }
        }

19 Source : Pack_Def_Data.cs
with MIT License
from Arefu

public override void Load(BinaryReader reader, long length, Localized_Text.Language language)
        {
            var fileStartPos = reader.BaseStream.Position;

            var count = (uint) reader.ReadUInt64();
            for (uint i = 0; i < count; i++)
            {
                var id = reader.ReadInt32();
                var series = (Duel_Series) reader.ReadInt32();
                var price = reader.ReadInt32();
                var type = (PackType) reader.ReadInt32();
                var codeNameOffset = reader.ReadInt64();
                var nameOffset = reader.ReadInt64();
                var unkStrOffset = reader.ReadInt64();

                var tempOffset = reader.BaseStream.Position;

                reader.BaseStream.Position = fileStartPos + codeNameOffset;
                var codeName = reader.ReadNullTerminatedString(encoding1);

                reader.BaseStream.Position = fileStartPos + nameOffset;
                var name = reader.ReadNullTerminatedString(encoding2);

                reader.BaseStream.Position = fileStartPos + unkStrOffset;
                var unkStr = reader.ReadNullTerminatedString(encoding2);

                reader.BaseStream.Position = tempOffset;

                if (!Items.TryGetValue(id, out var item))
                {
                    item = new Item(id, series, price, type);
                    Items.Add(item.Id, item);
                }

                item.CodeName.SetText(language, codeName);
                item.Name.SetText(language, name);
                item.UnkStr.SetText(language, unkStr);
            }
        }

19 Source : Script_Data.cs
with MIT License
from Arefu

public override void Load(BinaryReader reader, long length, Localized_Text.Language language)
        {
            var fileStartPos = reader.BaseStream.Position;

            var firstChunkSize = reader.ReadInt64();

            var firstChunkItemCount = reader.ReadInt32();
            var secondChunkItemCount = reader.ReadInt32();

            for (var i = 0; i < firstChunkItemCount; i++)
            {
                var textStartIndex = reader.ReadInt32();
                var textEndIndex = reader.ReadInt32();
                var codeNameOffset = reader.ReadInt64();

                var tempOffset = reader.BaseStream.Position;
                reader.BaseStream.Position = fileStartPos + codeNameOffset;
                var codeName = reader.ReadNullTerminatedString(encoding);
                reader.BaseStream.Position = tempOffset;

                Script script = null;
                if (Scripts.Count > i)
                    script = Scripts[i];
                else
                    Scripts.Add(script = new Script(textStartIndex, textEndIndex));
                script.CodeName.SetText(language, codeName);
            }

            reader.BaseStream.Position = fileStartPos + firstChunkSize;

            for (var i = 0; i < secondChunkItemCount; i++)
            {
                var characterNameOffset = reader.ReadInt64();
                var characterPositionOffset = reader.ReadInt64();
                var characterExpressionOffset = reader.ReadInt64();
                var textOffset = reader.ReadInt64();

                var tempOffset = reader.BaseStream.Position;

                reader.BaseStream.Position = fileStartPos + characterNameOffset;
                var characterName = reader.ReadNullTerminatedString(encoding);

                reader.BaseStream.Position = fileStartPos + characterPositionOffset;
                var characterPosition = reader.ReadNullTerminatedString(encoding);

                reader.BaseStream.Position = fileStartPos + characterExpressionOffset;
                var characterExpression = reader.ReadNullTerminatedString(encoding);

                reader.BaseStream.Position = fileStartPos + textOffset;
                var text = reader.ReadNullTerminatedString(encoding);

                reader.BaseStream.Position = tempOffset;

                ScriptText scriptText = null;
                if (Text.Count > i)
                    scriptText = Text[i];
                else
                    Text.Add(scriptText = new ScriptText());
                scriptText.CharacterName.SetText(language, characterName);
                scriptText.CharacterPosition.SetText(language, characterPosition);
                scriptText.CharacterExpression.SetText(language, characterExpression);
                scriptText.Text.SetText(language, text);
            }
        }

19 Source : SKU_Data.cs
with MIT License
from Arefu

public override void Load(BinaryReader reader, long length, Localized_Text.Language language)
        {
            var fileStartPos = reader.BaseStream.Position;

            var count = (uint) reader.ReadUInt64();
            for (uint i = 0; i < count; i++)
            {
                var id = reader.ReadInt32();
                var series = (Duel_Series) reader.ReadInt32();
                var keyOffset = reader.ReadInt64();
                var valueOffset = reader.ReadInt64();

                var tempOffset = reader.BaseStream.Position;

                reader.BaseStream.Position = fileStartPos + keyOffset;
                var key = reader.ReadNullTerminatedString(keyEncoding);

                reader.BaseStream.Position = fileStartPos + valueOffset;
                var value = reader.ReadNullTerminatedString(valueEncoding);

                reader.BaseStream.Position = tempOffset;

                if (!Items.TryGetValue(id, out var item))
                {
                    item = new Item(id, series);
                    Items.Add(item.Id, item);
                }

                item.Key.SetText(language, key);
                item.Value.SetText(language, value);
            }
        }

19 Source : Battle_Pack_Save.cs
with MIT License
from Arefu

public override void Load(BinaryReader reader)
        {
            Unk1 = reader.ReadByte();
            State = (BattlePackSaveState) reader.ReadInt32();
            NumDuelsCompleted = reader.ReadInt32();
            NumDuelsWon = reader.ReadInt32();
            NumDuelsLost = reader.ReadInt32();
            Unk2 = reader.ReadInt32();
            DuelResult1 = (BattlePackDuelResult) reader.ReadInt32();
            DuelResult2 = (BattlePackDuelResult) reader.ReadInt32();
            DuelResult3 = (BattlePackDuelResult) reader.ReadInt32();
            DuelResult4 = (BattlePackDuelResult) reader.ReadInt32();
            DuelResult5 = (BattlePackDuelResult) reader.ReadInt32();

            LoadDeckData(reader);

            Type = (BattlePackType) reader.ReadInt32();

            for (var i = 0; i < NumDraftedCards; i++)
            {
                var cardId = reader.ReadInt16();
                if (cardId > 0) DraftedCards.Add(cardId);
            }

            Unk3 = reader.ReadInt32();
            Unk4 = reader.ReadInt32();
            Unk5 = reader.ReadInt32();
            Unk6 = reader.ReadByte();

            LoadSealedCards(reader, SealedCards1);
            LoadSealedCards(reader, SealedCards2);
            LoadSealedCards(reader, SealedCards3);
        }

19 Source : Campaign_Save.cs
with MIT License
from Arefu

public override void Load(BinaryReader reader)
        {
            reader.ReadInt32();
            reader.ReadInt32();

            for (var i = 0; i < Constants.NumDuelSeries; i++)
            {
                var series = IndexToSeries(i);

                var duels = DuelsBySeries[series];
                for (var j = 0; j < DuelsPerSeries; j++)
                {
                    duels[j].Read(reader);
                    if (j != 0) continue;
                    reader.ReadInt32();
                    reader.ReadInt32();
                }
            }
        }

19 Source : Campaign_Save.cs
with MIT License
from Arefu

public void Read(BinaryReader reader)
            {
                State = (CampaignDuelState) reader.ReadInt32();
                ReverseDuelState = (CampaignDuelState) reader.ReadInt32();
                Unk1 = reader.ReadInt32();
                Unk2 = reader.ReadInt32();
                Unk3 = reader.ReadInt32();
                Unk4 = reader.ReadInt32();
            }

19 Source : Deck_Save_Database.cs
with MIT License
from Arefu

public void LoadDeckData(BinaryReader Reader)
        {
            DeckName = Encoding.Unicode.GetString(Reader.ReadBytes(Constants.DeckNameByteLen)).TrimEnd('\0');

            var NumMainDeckCards = Reader.ReadInt16();
            var NumSideDeckCards = Reader.ReadInt16();
            var NumExtraDeckCards = Reader.ReadInt16();

            for (var Count = 0; Count < MaxMainDeckCards; Count++)
            {
                var CardId = Reader.ReadInt16();
                if (CardId > 0) MainDeckCards.Add(CardId);
            }

            for (var Count = 0; Count < MaxSideDeckCards; Count++)
            {
                var CardId = Reader.ReadInt16();
                if (CardId > 0) SideDeckCards.Add(CardId);
            }

            for (var Count = 0; Count < MaxExtraDeckCards; Count++)
            {
                var CardId = Reader.ReadInt16();
                if (CardId > 0) ExtraDeckCards.Add(CardId);
            }

            Reader.ReadBytes(12);
            Reader.ReadBytes(12);
            Reader.ReadUInt32();
            Reader.ReadUInt32();
            Reader.ReadUInt32();
            DeckAvatarId = Reader.ReadInt32();
            Reader.ReadUInt32();
            Reader.ReadUInt32();
            IsDeckComplete = Reader.ReadUInt32() == 1;
        }

19 Source : Game_Save.cs
with MIT License
from Arefu

private bool Load(byte[] Buffer, bool CheckSignature)
        {
            Clear();

            try
            {
                using (var Reader = new BinaryReader(new MemoryStream(Buffer)))
                {
                    var Signature = Reader.ReadUInt32();
                    if (CheckSignature)
                    {
                        var CalculatedSignature = GetSignature(Buffer);
                        Debug.replacedert(CalculatedSignature == Signature, "Bad save data signature");
                    }

                    PlayCount = Reader.ReadInt32();

                    Stats.Load(Reader);

                    for (var Counter = 0; Counter < Constants.NumBattlePacks; Counter++)
                        BattlePacks[Counter].Load(Reader);

                    Misc.Load(Reader);

                    Campaign.Load(Reader);

                    for (var Counter = 0; Counter < Constants.NumUserDecks; Counter++) Decks[Counter].Load(Reader);

                    CardList.Load(Reader);
                }

                return true;
            }
            catch
            {
                return false;
            }
        }

19 Source : Misc_Save.cs
with MIT License
from Arefu

public override void Load(BinaryReader Reader)
        {
            Reader.ReadBytes(16);

            DuelPoints = (int) Reader.ReadInt64();

            var UnlockedAvatarsBuffer = Reader.ReadBytes(32);
            for (var Counter = 0; Counter < UnlockedAvatars.Length; Counter++)
            {
                var ByteIndex = Counter / 8;
                var BitIndex = Counter % 8;
                UnlockedAvatars[Counter] = (UnlockedAvatarsBuffer[ByteIndex] & (byte) (1 << BitIndex)) != 0;
            }

            for (var Count = 0; Count < Constants.NumDeckDataSlots; Count++)
                Challenges[Count] = (DeulistChallengeState) Reader.ReadInt32();

            var UnlockedRecipesBuffer = Reader.ReadBytes(60);
            for (var Counter = 0; Counter < Constants.NumDeckDataSlots; Counter++)
            {
                var ByteIndex = Counter / 8;
                var BitIndex = Counter % 8;
                UnlockedRecipes[Counter] = (UnlockedRecipesBuffer[ByteIndex] & (byte) (1 << BitIndex)) != 0;
            }

            UnlockedShopPacks = (UnlockedShopPacks) Reader.ReadUInt32();
            UnlockedBattlePacks = (UnlockedBattlePacks) Reader.ReadUInt32();
            Reader.ReadBytes(8);

            CompleteTutorials = (CompleteTutorials) Reader.ReadInt32();
            UnlockedContent = (UnlockedContent) Reader.ReadInt32();
        }

19 Source : Arena_Data.cs
with MIT License
from Arefu

public override void Load(BinaryReader reader, long length, Localized_Text.Language language)
        {
            var fileStartPos = reader.BaseStream.Position;

            var count = (uint) reader.ReadUInt64();
            for (uint i = 0; i < count; i++)
            {
                var id = reader.ReadInt32();
                var keyOffset = reader.ReadInt64();
                var valueOffset = reader.ReadInt64();
                var value2Offset = reader.ReadInt64();

                var tempOffset = reader.BaseStream.Position;

                reader.BaseStream.Position = fileStartPos + keyOffset;
                var key = reader.ReadNullTerminatedString(keyEncoding);

                reader.BaseStream.Position = fileStartPos + valueOffset;
                var value = reader.ReadNullTerminatedString(valueEncoding);

                reader.BaseStream.Position = fileStartPos + value2Offset;
                var value2 = reader.ReadNullTerminatedString(valueEncoding);

                reader.BaseStream.Position = tempOffset;

                if (!Items.TryGetValue(id, out var item))
                {
                    item = new Item(id);
                    Items.Add(item.Id, item);
                }

                item.Key.SetText(language, key);
                item.Value.SetText(language, value);
                item.Value2.SetText(language, value2);
            }
        }

19 Source : Deck_Data.cs
with MIT License
from Arefu

public override void Load(BinaryReader reader, long length, Localized_Text.Language language)
        {
            var fileStartPos = reader.BaseStream.Position;

            var count = (uint) reader.ReadUInt64();
            for (uint i = 0; i < count; i++)
            {
                var id1 = reader.ReadInt32();
                var id2 = reader.ReadInt32();
                var series = (Duel_Series) reader.ReadInt32();
                var signatureCardId = reader.ReadInt32();
                var deckOwner = reader.ReadInt32();
                var unk1 = reader.ReadInt32();
                var deckFileNameOffset = reader.ReadInt64();
                var deckNameOffset = reader.ReadInt64();
                var deckDescriptionOffset = reader.ReadInt64();
                var unkStr1Offset = reader.ReadInt64();

                var tempOffset = reader.BaseStream.Position;

                reader.BaseStream.Position = fileStartPos + deckFileNameOffset;
                var deckFileName = reader.ReadNullTerminatedString(deckFileNameEncoding);

                reader.BaseStream.Position = fileStartPos + deckNameOffset;
                var deckName = reader.ReadNullTerminatedString(deckNameEncoding);

                reader.BaseStream.Position = fileStartPos + deckDescriptionOffset;
                var deckDescription = reader.ReadNullTerminatedString(deckDescriptionEncoding);

                reader.BaseStream.Position = fileStartPos + unkStr1Offset;
                var unkStr1 = reader.ReadNullTerminatedString(unkStr1Encoding);

                reader.BaseStream.Position = tempOffset;

                if (!Items.TryGetValue(id1, out var item))
                {
                    item = new Item(id1, id2, series, signatureCardId, deckOwner, unk1);
                    Items.Add(item.Id1, item);
                }

                item.DeckFileName.SetText(language, deckFileName);
                item.DeckName.SetText(language, deckName);
                item.DeckDescription.SetText(language, deckDescription);
                item.UnkStr1.SetText(language, unkStr1);
            }
        }

19 Source : Duel_Data.cs
with MIT License
from Arefu

public override void Load(BinaryReader reader, long length, Localized_Text.Language language)
        {
            var fileStartPos = reader.BaseStream.Position;

            var count = (uint) reader.ReadUInt64();
            for (uint i = 0; i < count; i++)
            {
                var id = reader.ReadInt32();
                var series = (Duel_Series) reader.ReadInt32();
                var displayIndex = reader.ReadInt32();
                var playerCharId = reader.ReadInt32();
                var opponentCharId = reader.ReadInt32();
                var playerDeckId = reader.ReadInt32();
                var opponentDeckId = reader.ReadInt32();
                var arenaId = reader.ReadInt32();
                var unk8 = reader.ReadInt32();
                var dlcId = reader.ReadInt32();
                var codeNameOffset = reader.ReadInt64();
                var playerAlternateSkinOffset = reader.ReadInt64();
                var opponentAlternateSkinOffset = reader.ReadInt64();
                var nameOffset = reader.ReadInt64();
                var descriptionOffset = reader.ReadInt64();
                var tipOffset = reader.ReadInt64();

                var tempOffset = reader.BaseStream.Position;

                reader.BaseStream.Position = fileStartPos + codeNameOffset;
                var codeName = reader.ReadNullTerminatedString(encoding1);

                reader.BaseStream.Position = fileStartPos + playerAlternateSkinOffset;
                var playerAlternateSkin = reader.ReadNullTerminatedString(encoding1);

                reader.BaseStream.Position = fileStartPos + opponentAlternateSkinOffset;
                var opponentAlternateSkin = reader.ReadNullTerminatedString(encoding1);

                reader.BaseStream.Position = fileStartPos + nameOffset;
                var name = reader.ReadNullTerminatedString(encoding2);

                reader.BaseStream.Position = fileStartPos + descriptionOffset;
                var description = reader.ReadNullTerminatedString(encoding2);

                reader.BaseStream.Position = fileStartPos + tipOffset;
                var tipStr = reader.ReadNullTerminatedString(encoding2);

                reader.BaseStream.Position = tempOffset;

                if (!Items.TryGetValue(id, out var item))
                {
                    item = new Item(id, series, displayIndex, playerCharId, opponentCharId, playerDeckId,
                        opponentDeckId, arenaId, unk8, dlcId);
                    Items.Add(item.Id, item);
                }

                item.CodeName.SetText(language, codeName);
                item.PlayerAlternateSkin.SetText(language, playerAlternateSkin);
                item.OpponentAlternateSkin.SetText(language, opponentAlternateSkin);
                item.Name.SetText(language, name);
                item.Description.SetText(language, description);
                item.Tip.SetText(language, tipStr);
            }
        }

19 Source : Battle_Pack_Save.cs
with MIT License
from Arefu

private static void LoadSealedCards(BinaryReader reader, List<short> sealedCards)
        {
            var numSealedCards = reader.ReadInt32();
            for (var i = 0; i < NumSealedCardsPerSegment; i++)
            {
                var cardId = reader.ReadInt16();
                if (cardId > 0) sealedCards.Add(cardId);
            }
        }

19 Source : Binary_filetype.cs
with GNU Affero General Public License v3.0
from arklumpus

public static IEnumerable<TreeNode> OpenFile(string fileName, List<(string, Dictionary<string, object>)> moduleSuggestions, Action<double> progressAction, Func<RSAParameters?, bool> askForCodePermission)
        {
            FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read);
			
			List<Attachment> attachments = new List<Attachment>();

            if (BinaryTree.HasValidTrailer(fs, true))
            {
                try
                {
                    using (BinaryReader reader = new BinaryReader(fs, System.Text.Encoding.UTF8, true))
                    {
                        fs.Seek(-12, SeekOrigin.End);
                        long labelAddress = reader.ReadInt64();
                        fs.Seek(labelAddress - 8, SeekOrigin.Begin);
                        long dataLength = reader.ReadInt64();
                        if (dataLength > 11)
                        {
                            fs.Seek(labelAddress - 8 - dataLength, SeekOrigin.Begin);
                            string header = reader.ReadString();
							string serializedModules = null; 
							
                            if (header == "#TreeViewer")
                            {
                                serializedModules = reader.ReadString();

                                if (reader.BaseStream.Position - (labelAddress - 8 - dataLength) < dataLength)
                                {
                                    try
                                    {
                                        header = reader.ReadString();
                                    }
                                    catch { }
                                }
                            }


                            if (header == "#Attachments")
                            {
                                int attachmentCount = reader.ReadInt32();

                                for (int i = 0; i < attachmentCount; i++)
                                {
                                    Attachment att = ReadAttachment(reader, fileName);
									attachments.Add(att);
                                    moduleSuggestions.Add(("@Attachment", new Dictionary<string, object>() { { "Attachment", att } }));
                                }
                            }
							
							if (serializedModules != null)
							{
								List<List<(string, Dictionary<string, object>)>> modules = ModuleUtils.DeserializeModules(serializedModules, attachments, askForCodePermission);

                                if (modules[0].Count > 0)
                                {
                                    moduleSuggestions[0] = modules[0][0];
                                }

                                if (modules[2].Count > 0)
                                {
                                    moduleSuggestions[1] = modules[2][0];
                                }

                                for (int i = 0; i < modules[1].Count; i++)
                                {
                                    moduleSuggestions.Add(modules[1][i]);
                                }

                                for (int i = 0; i < modules[3].Count; i++)
                                {
                                    moduleSuggestions.Add(modules[3][i]);
                                }
							}
                        }
                    }
                }
                catch { }

                fs.Seek(0, SeekOrigin.Begin);

                return new TreeCollection(fs);
            }
            else
            {
                return BinaryTree.ParseTrees(fs, progressAction: progressAction);
            }
        }

19 Source : Binary_filetype.cs
with GNU Affero General Public License v3.0
from arklumpus

private static Attachment ReadAttachment(BinaryReader reader, string fileName)
        {
            string name = reader.ReadString();

            int flagCount = reader.ReadInt32();

            bool storeInMemory = false;
            bool cacheResults = false;

            for (int i = 0; i < flagCount; i++)
            {
                bool flag = reader.ReadBoolean();

                if (i == 0)
                {
                    storeInMemory = flag;
                }
                else if (i == 1)
                {
                    cacheResults = flag;
                }
            }

            int length = reader.ReadInt32();

            if (storeInMemory)
            {
                byte[] data = reader.ReadBytes(length);

                Stream ms = new MemoryStream(data);

                return new Attachment(name, cacheResults, storeInMemory, ref ms);
            }
            else
            {
                long streamStart = reader.BaseStream.Position;

                return new Attachment(name, cacheResults, fileName, streamStart, length);
            }
        }

19 Source : QBTFile.cs
with MIT License
from ArnaudValensi

public void LoadQB2(BinaryReader stream) {
		// Load Header
		int magic = stream.ReadInt32();
		byte major = stream.ReadByte();
		byte minor = stream.ReadByte();

		if (showLogs) {
			Debug.LogFormat("[QBT] version {0}.{1}", major, minor);
		}

		if (magic != 0x32204251) {
			throw new UnityException("magic does not match. Expected: " + 0x32204251 + ", got: " + magic);
		}

		Vector3 globalScale = new Vector3();
		globalScale.x = stream.ReadSingle();
		globalScale.y = stream.ReadSingle();
		globalScale.z = stream.ReadSingle();

		// Load Color Map
		string colormapStr = new string(stream.ReadChars(8)); // = COLORMAP

		if (colormapStr != "COLORMAP") {
			throw new UnityException("expected 'COLORMAP', got " + colormapStr);
		}

		uint colorCount = stream.ReadUInt32();

		if (showLogs) {
			Debug.LogFormat("[QBT] color count: {0}", colorCount);
		}

		int[] colors = new int[colorCount];
		for (uint i = 0; i < colorCount; i++) {
			colors[i] = stream.ReadInt32();
		}

		// Load Data Tree
		string datatreeStr = new string(stream.ReadChars(8)); // = DATATREE

		if (datatreeStr != "DATATREE") {
			throw new UnityException("expected 'DATATREE', got " + datatreeStr);
		}

		LoadNode(stream);
	}

19 Source : QBTFile.cs
with MIT License
from ArnaudValensi

void LoadMatrix(BinaryReader stream) {
		if (showLogs) {
			Debug.Log("[QBT] LoadMatrix");
		}

		int nameLength = stream.ReadInt32();
		string name = new string(stream.ReadChars(nameLength));

		if (showLogs) {
			Debug.Log("[QBT] name: " + name);
		}

		Vector3 position = new Vector3();
		position.x = stream.ReadInt32();
		position.y = stream.ReadInt32();
		position.z = stream.ReadInt32();

		Vector3 localScale = new Vector3();
		localScale.x = stream.ReadUInt32();
		localScale.y = stream.ReadUInt32();
		localScale.z = stream.ReadUInt32();

		Vector3 pivot = new Vector3();
		pivot.x = stream.ReadSingle();
		pivot.y = stream.ReadSingle();
		pivot.z = stream.ReadSingle();

		Vector3 size = new Vector3();
		size.x = stream.ReadUInt32();
		size.y = stream.ReadUInt32();
		size.z = stream.ReadUInt32();

		// Compressed voxel data size.
		stream.ReadUInt32();

		voxelsData = new VoxelData[(int)size.x, (int)size.y, (int)size.z];

		var zlibStream = new ZlibStream(stream.BaseStream, Ionic.Zlib.CompressionMode.Decompress, true);
		for (uint x = 0; x < size.x; x++) {
			for (uint z = 0; z < size.z; z++) {
				for (uint y = 0; y < size.y; y++) {
					VoxelData data = new VoxelData();

					data.r = (byte)zlibStream.ReadByte();
					data.g = (byte)zlibStream.ReadByte();
					data.b = (byte)zlibStream.ReadByte();
					data.m = (byte)zlibStream.ReadByte();

					voxelsData[x, y, z] = data;
					colors.Add(data.Color);
				}
			}
		}
	}

19 Source : QBTFile.cs
with MIT License
from ArnaudValensi

void LoadCompound(BinaryReader stream) {
		if (showLogs) {
			Debug.Log("[QBT] LoadCompound");
		}

		int nameLength = stream.ReadInt32();
		string name = new string(stream.ReadChars(nameLength));

		if (showLogs) {
			Debug.Log("[QBT] name: " + name);
		}

		Vector3 position = new Vector3();
		position.x = stream.ReadInt32();
		position.y = stream.ReadInt32();
		position.z = stream.ReadInt32();

		Vector3 localScale = new Vector3();
		localScale.x = stream.ReadUInt32();
		localScale.y = stream.ReadUInt32();
		localScale.z = stream.ReadUInt32();

		Vector3 pivot = new Vector3();
		pivot.x = stream.ReadSingle();
		pivot.y = stream.ReadSingle();
		pivot.z = stream.ReadSingle();

		Vector3 size = new Vector3();
		size.x = stream.ReadUInt32();
		size.y = stream.ReadUInt32();
		size.z = stream.ReadUInt32();

		// Compressed voxel data size.
		stream.ReadUInt32();

		// TODO: voxelsData is overwrited
		voxelsData = new VoxelData[(int)size.x, (int)size.y, (int)size.z];

		var zlibStream = new ZlibStream(stream.BaseStream, Ionic.Zlib.CompressionMode.Decompress, true);
		for (uint x = 0; x < size.x; x++) {
			for (uint z = 0; z < size.z; z++) {
				for (uint y = 0; y < size.y; y++) {
					VoxelData data = new VoxelData();

					data.r = (byte)zlibStream.ReadByte();
					data.g = (byte)zlibStream.ReadByte();
					data.b = (byte)zlibStream.ReadByte();
					data.m = (byte)zlibStream.ReadByte();

					voxelsData[x, y, z] = data;
				}
			}
		}

		uint childCount = stream.ReadUInt32();
		if (mergeCompounds) { // if you don't need the datatree you can skip child nodes
			for (uint i = 0; i < childCount; i++) {
				SkipNode(stream);
			}
		} else {
			for (uint i = 0; i < childCount; i++) {
				LoadNode(stream);
			}
		}
	}

19 Source : SaveVoxelTerrain.cs
with MIT License
from ArnaudValensi

void LoadData(BinaryReader reader) {
			int nbChunks = reader.ReadInt32();

			for (int i = 0; i < nbChunks; i++) {
				int sizeX = reader.ReadInt32();
				int sizeY = reader.ReadInt32();
				int sizeZ = reader.ReadInt32();
				int posX = reader.ReadInt32();
				int posY = reader.ReadInt32();
				int posZ = reader.ReadInt32();

				RLEDecode(reader, sizeX, sizeY, sizeZ, posX, posY, posZ);
			}
		}

19 Source : QBTFile.cs
with MIT License
from ArnaudValensi

void SkipNode(BinaryReader stream) {
		if (showLogs) {
			Debug.Log("[QBT] SkipNode");
		}

		stream.ReadInt32(); // node type, can be ignored
		uint dataSize = stream.ReadUInt32();
		stream.ReadChars((int) dataSize);
	}

19 Source : SaveVoxelTerrain.cs
with MIT License
from ArnaudValensi

void RLEDecode(
			BinaryReader binaryReader, int sizeX, int sizeY, int sizeZ, int posX, int posY, int posZ
		) {
			int x = 0;
			int y = 0;
			int z = 0;
			byte type;
			int intColor;
			Color32 color;
			short count;
			int length = sizeX * sizeY * sizeZ;

			for (int i = 0; i < length;) {
				count = binaryReader.ReadInt16();
				type = binaryReader.ReadByte();
				intColor = binaryReader.ReadInt32();
				color = IntToColor32(intColor);

				for (int j = 0; j < count; j++) {
					// Add voxel if solid
					if ((Voxel.Type)type == Voxel.Type.Solid) {
						voxelTerrain.AddVoxel(
							new Pos(posX + x, posY + y, posZ + z),
							color
						);
					}

					x = (x + 1) % sizeX;

					if (x == 0) {
						y = (y + 1) % sizeY;

						if (y == 0) {
							z++;
						}
					}

					i++;
				}
			}
		}

19 Source : DDSImporter.cs
with GNU General Public License v3.0
from arycama

public static Texture ReadFile(BinaryReader reader)
	{
		// Read and check the magic string (Should be 'DDS ', or  0x20534444)
		var magic = reader.ReadInt32();
		if(magic != 0x20534444)
		{
			throw new Exception("DDS file invalid");
		}

		// Read the header
		var headerSize = reader.ReadInt32();
		var headerFlags = (HeaderFlags)reader.ReadInt32();
		var height = reader.ReadInt32();
		var width = reader.ReadInt32();
		var pitchOrLinearSize = reader.ReadInt32();
		var depth = reader.ReadInt32();
		var mipMapCount = reader.ReadInt32();
		var dwReserved1 = reader.ReadBytes(sizeof(int) * 11);

		// Read pixel format
		var formatSize = reader.ReadInt32();
		var formatFlags = (PixelFormatFlags)reader.ReadInt32();
		var fourCC = Encoding.ASCII.GetString(reader.ReadBytes(4));
		var rgbBitCount = reader.ReadInt32();
		var redBitMask = reader.ReadInt32();
		var greenBitMask = reader.ReadInt32();
		var blueBitMask = reader.ReadInt32();
		var alphaBitMask = reader.ReadInt32();

		var Caps = (HeaderCaps)reader.ReadInt32();
		var Caps2 = reader.ReadInt32();
		var Caps3 = reader.ReadInt32();
		var Caps4 = reader.ReadInt32();
		var Reserved2 = reader.ReadInt32();

		// Get the size of the top level of the texture from the header, and read it
		var dataSize = formatFlags.HasFlag(PixelFormatFlags.FourCC) ? pitchOrLinearSize : pitchOrLinearSize * height;
		int missingDataSize;

		int bytesPerBlock;
		GraphicsFormat textureFormat;
		switch (formatFlags)
		{
			case (PixelFormatFlags.AlphaPixels | PixelFormatFlags.Rgb):
				bytesPerBlock = rgbBitCount;
				textureFormat = GraphicsFormat.B8G8R8A8_SRGB;
				break;
			case PixelFormatFlags.FourCC:
				switch (fourCC)
				{
					case "DXT1":
						bytesPerBlock = 8;
						textureFormat = GraphicsFormat.RGBA_DXT1_SRGB;
						break;
					case "DXT3":
						bytesPerBlock = 16;
						textureFormat = GraphicsFormat.RGBA_DXT3_SRGB;
						break;
					case "DXT5":
						bytesPerBlock = 16;
						textureFormat = GraphicsFormat.RGBA_DXT5_SRGB;
						break;
					default:
						throw new NotImplementedException(fourCC);
				}
				break;
			default:
				throw new NotImplementedException(formatFlags.ToString());
		}

		var hasMipMaps = Caps.HasFlag(HeaderCaps.Complex) || Caps.HasFlag(HeaderCaps.Mipmap);
		var data2Size = GetData2Size(width, height, bytesPerBlock, dataSize, mipMapCount, hasMipMaps, out missingDataSize);

		var data = new byte[dataSize + data2Size + missingDataSize];
		reader.Read(data, 0, dataSize + data2Size);

		var flags = hasMipMaps ? TextureCreationFlags.MipChain : TextureCreationFlags.None;
		var texture = new Texture2D(width, height, textureFormat, mipMapCount, flags);
		texture.LoadRawTextureData(data);
		texture.Apply(false, true);

		return texture;
	}

See More Examples