Beispiel #1
0
        public static MessageFile FromBytes(IEnumerable <byte> data)
        {
            var result = new MessageFile();

            if (data.Count() == 0)
            {
                return(result);
            }

            using (var stream = new MemoryStream(data.ToArray()))
                using (var reader = new BinaryReader(stream))
                {
                    // strings are variable length so the header contains offsets for each
                    var positions = new List <uint>()
                    {
                        reader.ReadUInt32()
                    };
                    while (stream.Position < positions[0])
                    {
                        positions.Add(reader.ReadUInt32());
                    }

                    // eof
                    positions.Add((uint)stream.Length);

                    // read & decode strings
                    for (int i = 1; i < positions.Count; i++)
                    {
                        var messageData = reader.ReadBytes((int)positions[i] - (int)stream.Position);
                        result.Messages.Add(FF8String.Decode(messageData));
                    }
                }

            return(result);
        }
Beispiel #2
0
        public Kernel(Stream stream)
        {
            using (var reader = new BinaryReader(stream))
            {
                var sectionCount   = reader.ReadUInt32();
                var sectionOffsets = new List <uint>();
                for (int i = 0; i < sectionCount; i++)
                {
                    sectionOffsets.Add(reader.ReadUInt32());
                }

                // sections 0-1
                stream.Seek(0, SeekOrigin.Begin);
                PreGFData = reader.ReadBytes((int)(sectionOffsets[2]));

                // section 2 = junctionable gf
                JunctionableGFs = new JunctionableGF[16];
                for (int i = 0; i < 16; i++)
                {
                    JunctionableGFs[i] = new JunctionableGF(reader.ReadBytes(132));
                }

                // section 3
                PostGFData = reader.ReadBytes((int)(sectionOffsets[4] - stream.Position));

                // section 4 = weapons
                Weapons = new Weapon[33];
                for (int i = 0; i < 33; i++)
                {
                    Weapons[i] = new Weapon(reader.ReadBytes(12));
                }

                //sections 5-10
                PostWeaponData = reader.ReadBytes((int)(sectionOffsets[11] - stream.Position));

                // sections 11-17 = abilities
                var abilities = new List <Ability>();
                while (sectionOffsets[18] - stream.Position >= 8)
                {
                    abilities.Add(new Ability(reader.ReadBytes(8)));
                }
                Abilities = abilities.ToArray();

                // sections 18-34
                PostAbilityData = reader.ReadBytes((int)(sectionOffsets[35] - stream.Position));

                // section 35 = weapon text
                WeaponText = reader.ReadBytes((int)(sectionOffsets[36] - stream.Position));
                foreach (var w in Weapons)
                {
                    w.Name = FF8String.Decode(WeaponText.Skip(w.NameOffset).ToArray());
                }

                // sections 36-55
                PostWeaponTextData = reader.ReadBytes((int)(stream.Length - stream.Position));
            }
        }
Beispiel #3
0
        public MonsterAI(IEnumerable <byte> data)
        {
            using (var stream = new MemoryStream(data.ToArray()))
                using (var reader = new BinaryReader(stream))
                {
                    var subSections     = reader.ReadUInt32();
                    var aiOffset        = reader.ReadUInt32();
                    var textIndexOffset = reader.ReadUInt32();
                    var textOffset      = reader.ReadUInt32();

                    // extract battle AI script
                    stream.Position = aiOffset;
                    var aiLength = textIndexOffset - aiOffset;
                    Scripts = new BattleScript(reader.ReadBytes((int)aiLength));

                    // extract text strings
                    stream.Position = textIndexOffset;
                    var textOffsets = new List <uint>();
                    var textLengths = new List <uint>();
                    for (int i = 0; i < (textOffset - textIndexOffset) / 2; i++)
                    {
                        var newOffset = reader.ReadUInt16();
                        if (i > 0)
                        {
                            // use this string's offset to fill in how long the previous string was
                            var prevOffset = textOffsets.Last();
                            if (newOffset < prevOffset)
                            {
                                break;
                            }
                            textLengths.Add(newOffset - prevOffset);
                        }
                        textOffsets.Add(newOffset);
                    }

                    // final string ends at EOF
                    if (textOffsets.Count > 0)
                    {
                        textLengths.Add((uint)stream.Length - (textOffset + textOffsets.Last()));
                    }

                    // decode strings
                    for (int i = 0; i < textOffsets.Count; i++)
                    {
                        stream.Position = textOffset + textOffsets[i];
                        var newText = reader.ReadBytes((int)textLengths[i]);
                        Strings.Add(FF8String.Decode(newText));
                    }
                }
        }
Beispiel #4
0
 public InitGF(byte[] data)
 {
     using (var stream = new MemoryStream(data))
         using (var reader = new BinaryReader(stream))
         {
             Name               = FF8String.Decode(reader.ReadBytes(12));
             Exp                = reader.ReadInt32();
             Unknown            = reader.ReadByte();
             Exists             = reader.ReadByte();
             HP                 = reader.ReadInt16();
             Abilities          = new BitArray(reader.ReadBytes(16));
             AP                 = reader.ReadBytes(24);
             Kills              = reader.ReadInt16();
             Deaths             = reader.ReadInt16();
             CurrentAbility     = reader.ReadByte();
             ForgottenAbilities = new BitArray(reader.ReadBytes(3));
         }
 }
Beispiel #5
0
        public MonsterInfo(IEnumerable <byte> data)
        {
            using (var stream = new MemoryStream(data.ToArray()))
                using (var reader = new BinaryReader(stream))
                {
                    Name = FF8String.Decode(reader.ReadBytes(24));

                    Hp  = reader.ReadBytes(4);
                    Str = reader.ReadBytes(4);
                    Vit = reader.ReadBytes(4);
                    Mag = reader.ReadBytes(4);
                    Spr = reader.ReadBytes(4);
                    Spd = reader.ReadBytes(4);
                    Eva = reader.ReadBytes(4);

                    for (int i = 0; i < 16; i++)
                    {
                        AbilitiesLow[i] = new MonsterAbility(reader.ReadBytes(4));
                    }
                    for (int i = 0; i < 16; i++)
                    {
                        AbilitiesMed[i] = new MonsterAbility(reader.ReadBytes(4));
                    }
                    for (int i = 0; i < 16; i++)
                    {
                        AbilitiesHigh[i] = new MonsterAbility(reader.ReadBytes(4));
                    }

                    MedStart      = reader.ReadByte();
                    HighStart     = reader.ReadByte();
                    MysteryFlags1 = reader.ReadByte();
                    StatusFlags1  = reader.ReadByte();

                    CardDrop      = reader.ReadByte();
                    CardMorph     = reader.ReadByte();
                    CardRareMorph = reader.ReadByte();

                    DevourLow  = reader.ReadByte();
                    DevourMed  = reader.ReadByte();
                    DevourHigh = reader.ReadByte();

                    StatusFlags2  = reader.ReadByte();
                    MysteryFlags2 = reader.ReadByte();

                    ExtraExp = reader.ReadUInt16();
                    Exp      = reader.ReadUInt16();

                    for (int i = 0; i < 4; i++)
                    {
                        DrawLow[i] = reader.ReadByte();
                        reader.ReadByte(); // padding
                    }

                    for (int i = 0; i < 4; i++)
                    {
                        DrawMed[i] = reader.ReadByte();
                        reader.ReadByte(); // padding
                    }

                    for (int i = 0; i < 4; i++)
                    {
                        DrawHigh[i] = reader.ReadByte();
                        reader.ReadByte(); // padding
                    }

                    for (int i = 0; i < 4; i++)
                    {
                        MugLow[i] = new HeldItem(reader.ReadBytes(2));
                    }
                    for (int i = 0; i < 4; i++)
                    {
                        MugMed[i] = new HeldItem(reader.ReadBytes(2));
                    }
                    for (int i = 0; i < 4; i++)
                    {
                        MugHigh[i] = new HeldItem(reader.ReadBytes(2));
                    }

                    for (int i = 0; i < 4; i++)
                    {
                        DropLow[i] = new HeldItem(reader.ReadBytes(2));
                    }
                    for (int i = 0; i < 4; i++)
                    {
                        DropMed[i] = new HeldItem(reader.ReadBytes(2));
                    }
                    for (int i = 0; i < 4; i++)
                    {
                        DropHigh[i] = new HeldItem(reader.ReadBytes(2));
                    }

                    MugRate  = reader.ReadByte();
                    DropRate = reader.ReadByte();

                    reader.ReadByte(); // padding
                    Ap = reader.ReadByte();

                    MysteryData = reader.ReadBytes(16);
                    ElemDef     = reader.ReadBytes(8);
                    StatusDef   = reader.ReadBytes(20);
                }
        }
Beispiel #6
0
        public static TextFile FromBytes(IEnumerable <byte> data, bool fixedLength)
        {
            var result = new TextFile();

            if (fixedLength)
            {
                result.FixedLength = data.Count();
            }

            using (var stream = new MemoryStream(data.ToArray()))
                using (var reader = new BinaryReader(stream))
                {
                    // enumerate pages
                    var pageCount = reader.ReadInt16();
                    for (var i = 0; i < pageCount; i++)
                    {
                        result.Pages.Add(new MenuTextPage(reader.ReadInt16()));
                    }

                    // read pages
                    foreach (var page in result.Pages)
                    {
                        // pages listed at location 0 aren't real
                        if (page.Location == 0)
                        {
                            continue;
                        }

                        // enumerate string offsets
                        stream.Seek(page.Location, SeekOrigin.Begin);
                        var offsetCount = reader.ReadInt16();
                        for (var i = 0; i < offsetCount; i++)
                        {
                            page.Offsets.Add(reader.ReadInt16());
                        }

                        // read strings
                        foreach (var offset in page.Offsets)
                        {
                            // strings listed at offset 0 aren't real
                            if (offset == 0)
                            {
                                continue;
                            }

                            stream.Seek(page.Location + offset, SeekOrigin.Begin);
                            var stringBytes = new List <byte>();
                            var nextByte    = byte.MaxValue;
                            while (nextByte != 0)
                            {
                                nextByte = reader.ReadByte();
                                stringBytes.Add(nextByte);
                            }

                            page.Strings.Add(FF8String.Decode(stringBytes));
                        }
                    }
                }

            return(result);
        }