Beispiel #1
0
        public byte[] Encode()
        {
            var result = new List <byte>();

            var name = FF8String.Encode(Name).ToList();

            while (name.Count < 12)
            {
                name.Add(0);
            }
            result.AddRange(name);

            result.AddRange(BitConverter.GetBytes(Exp));
            result.Add(Unknown);
            result.Add(Exists);
            result.AddRange(BitConverter.GetBytes(HP));

            var abilities = new byte[16];

            Abilities.CopyTo(abilities, 0);
            result.AddRange(abilities);

            result.AddRange(AP);
            result.AddRange(BitConverter.GetBytes(Kills));
            result.AddRange(BitConverter.GetBytes(Deaths));
            result.Add(CurrentAbility);

            var forgotten = new byte[3];

            ForgottenAbilities.CopyTo(forgotten, 0);
            result.AddRange(forgotten);

            return(result.ToArray());
        }
Beispiel #2
0
        public IEnumerable <byte> Encode()
        {
            // encode
            var encodedMessages = new List <IEnumerable <byte> >();

            foreach (var m in Messages)
            {
                encodedMessages.Add(FF8String.Encode(m));
            }

            // write header
            var result   = new List <byte>();
            var position = Messages.Count * 4;

            foreach (var e in encodedMessages)
            {
                result.AddRange(BitConverter.GetBytes(position));
                position += e.Count();
            }

            // write messages
            foreach (var e in encodedMessages)
            {
                result.AddRange(e);
            }

            return(result);
        }
Beispiel #3
0
        public IEnumerable <byte> Encode()
        {
            var result = new List <byte>();

            var encodedName = FF8String.Encode(Name).Take(12).ToList();

            result.AddRange(encodedName);
            result.AddRange(Enumerable.Repeat <byte>(0, 12 - encodedName.Count));

            result.AddRange(BitConverter.GetBytes(Exp));
            result.Add(Unknown);
            result.Add(Exists);
            result.AddRange(BitConverter.GetBytes(HP));

            var abilities = new byte[16];

            Abilities.CopyTo(abilities, 0);
            result.AddRange(abilities);

            result.AddRange(AP);
            result.AddRange(BitConverter.GetBytes(Kills));
            result.AddRange(BitConverter.GetBytes(Deaths));
            result.Add(CurrentAbility);

            var forgotten = new byte[3];

            ForgottenAbilities.CopyTo(forgotten, 0);
            result.AddRange(forgotten);

            return(result);
        }
Beispiel #4
0
        public IEnumerable <byte> Encode()
        {
            var result = new List <byte>();

            result.AddRange(BitConverter.GetBytes((short)Offsets.Count));

            var headerSize     = Offsets.Count * 2 + 2;
            var encodedStrings = new List <IEnumerable <byte> >();
            var firstOffset    = 0;
            var offsetEnum     = Offsets.GetEnumerator();

            offsetEnum.MoveNext();

            foreach (var s in Strings)
            {
                // fake offsets
                while (offsetEnum.Current == 0)
                {
                    result.Add(0);
                    result.Add(0);
                    offsetEnum.MoveNext();
                }

                // calculate offset
                var newOffset = headerSize + encodedStrings.Sum(es => es.Count());
                if (firstOffset == 0)
                {
                    firstOffset = newOffset;
                }
                result.AddRange(BitConverter.GetBytes((short)newOffset));
                offsetEnum.MoveNext();

                // put the actual data aside until the header is done
                encodedStrings.Add(FF8String.Encode(s));
            }

            // pad header as required (eg. fake offsets after the last real one)
            while (result.Count < firstOffset)
            {
                result.Add(0);
            }

            // write text data
            foreach (var es in encodedStrings)
            {
                result.AddRange(es);
            }

            return(result);
        }
Beispiel #5
0
        public IEnumerable <byte> Encode()
        {
            var encodedScripts = Scripts.Encode();
            var encodedStrings = Strings.ConvertAll(s => FF8String.Encode(s));

            uint subSections     = 3;
            uint headerLength    = (subSections + 1) * 4;
            uint aiLength        = (uint)encodedScripts.Count();
            uint textIndexLength = (uint)Strings.Count * 2;
            uint textLength      = (uint)encodedStrings.Sum(s => s.Count());
            uint totalLength     = headerLength + aiLength + textIndexLength + textLength;

            totalLength += 4 - (totalLength % 4);

            uint aiOffset        = headerLength;
            uint textIndexOffset = aiOffset + aiLength;
            uint textOffset      = textIndexOffset + textIndexLength;

            var result = new byte[totalLength];

            using (var stream = new MemoryStream(result))
                using (var writer = new BinaryWriter(stream))
                {
                    writer.Write(subSections);
                    writer.Write(aiOffset);
                    writer.Write(textIndexOffset);
                    writer.Write(textOffset);
                    writer.Write(encodedScripts);

                    ushort offset = 0;
                    for (int i = 0; i < encodedStrings.Count; i++)
                    {
                        writer.Write(offset);
                        offset += (ushort)encodedStrings[i].Count();
                    }

                    for (int i = 0; i < encodedStrings.Count; i++)
                    {
                        writer.Write(encodedStrings[i]);
                    }
                }

            return(result);
        }
Beispiel #6
0
        public byte[] Encode()
        {
            var result = new byte[380];

            using (var stream = new MemoryStream(result))
                using (var writer = new BinaryWriter(stream))
                {
                    var encodedName = FF8String.Encode(Name).Take(24).ToList();
                    writer.Write(encodedName);
                    writer.Write(Enumerable.Repeat <byte>(0, 24 - encodedName.Count));

                    writer.Write(Hp);
                    writer.Write(Str);
                    writer.Write(Vit);
                    writer.Write(Mag);
                    writer.Write(Spr);
                    writer.Write(Spd);
                    writer.Write(Eva);

                    for (int i = 0; i < 16; i++)
                    {
                        writer.Write(AbilitiesLow[i].Encode());
                    }
                    for (int i = 0; i < 16; i++)
                    {
                        writer.Write(AbilitiesMed[i].Encode());
                    }
                    for (int i = 0; i < 16; i++)
                    {
                        writer.Write(AbilitiesHigh[i].Encode());
                    }

                    writer.Write(MedStart);
                    writer.Write(HighStart);
                    writer.Write(MysteryFlags1);
                    writer.Write(StatusFlags1);

                    writer.Write(CardDrop);
                    writer.Write(CardMorph);
                    writer.Write(CardRareMorph);

                    writer.Write(DevourLow);
                    writer.Write(DevourMed);
                    writer.Write(DevourHigh);

                    writer.Write(StatusFlags2);
                    writer.Write(MysteryFlags2);
                    writer.Write(ExtraExp);
                    writer.Write(Exp);

                    for (int i = 0; i < 4; i++)
                    {
                        writer.Write(DrawLow[i]);
                        writer.Write((byte)0);
                    }

                    for (int i = 0; i < 4; i++)
                    {
                        writer.Write(DrawMed[i]);
                        writer.Write((byte)0);
                    }

                    for (int i = 0; i < 4; i++)
                    {
                        writer.Write(DrawHigh[i]);
                        writer.Write((byte)0);
                    }

                    for (int i = 0; i < 4; i++)
                    {
                        writer.Write(MugLow[i].Encode());
                    }
                    for (int i = 0; i < 4; i++)
                    {
                        writer.Write(MugMed[i].Encode());
                    }
                    for (int i = 0; i < 4; i++)
                    {
                        writer.Write(MugHigh[i].Encode());
                    }

                    for (int i = 0; i < 4; i++)
                    {
                        writer.Write(DropLow[i].Encode());
                    }
                    for (int i = 0; i < 4; i++)
                    {
                        writer.Write(DropMed[i].Encode());
                    }
                    for (int i = 0; i < 4; i++)
                    {
                        writer.Write(DropHigh[i].Encode());
                    }

                    writer.Write(MugRate);
                    writer.Write(DropRate);
                    writer.Write((byte)0);
                    writer.Write(Ap);
                    writer.Write(MysteryData);
                    writer.Write(ElemDef);
                    writer.Write(StatusDef);
                }
            return(result);
        }