Example #1
0
        public void MsgPackReader(string file, bool json)
        {
            Dex    = null;
            header = new Header();

            MsgPack msgPack = file.ReadMPAllAtOnce(json);
            MsgPack dex;

            if ((dex = msgPack["Dex", true]).NotNull)
            {
                Dex = new EXP[dex.Array.Length];
                for (i0 = 0; i0 < Dex.Length; i0++)
                {
                    Dex[i0] = new EXP {
                        Name = dex[i0].RS("Name")
                    };

                    MsgPack temp;
                    if ((temp = dex[i0]["Main", true]).NotNull)
                    {
                        Dex[i0].Main          = KKdList <EXPElement> .New;
                        Dex[i0].Main.Capacity = temp.Array.Length;
                        for (i1 = 0; i1 < Dex[i0].Main.Capacity; i1++)
                        {
                            Dex[i0].Main.Add(EXPElement.Read(temp[i1]));
                        }
                    }
                    if ((temp = dex[i0]["Eyes", true]).NotNull)
                    {
                        Dex[i0].Eyes          = KKdList <EXPElement> .New;
                        Dex[i0].Eyes.Capacity = temp.Array.Length;
                        for (i1 = 0; i1 < this.Dex[i0].Eyes.Capacity; i1++)
                        {
                            Dex[i0].Eyes.Add(EXPElement.Read(temp[i1]));
                        }
                    }
                    temp.Dispose();
                }
            }
            dex.Dispose();
            msgPack.Dispose();
        }
Example #2
0
 private MsgPack WriteEXP(EXPElement element) =>
 new MsgPack().Add("F", element.Frame).Add("B", element.Both).Add("I", element.ID)
 .Add("V", element.Value).Add("T", element.Trans);
Example #3
0
        public int DEXReader(string filepath, string ext)
        {
            Header = new PDHead();
            IO     = File.OpenReader(filepath + ext);

            Header.Format    = Main.Format.F;
            Header.Signature = IO.ReadInt32();
            if (Header.Signature == 0x43505845)
            {
                Header = IO.ReadHeader(true);
            }
            if (Header.Signature != 0x64)
            {
                return(0);
            }

            Offset = IO.Position - 0x4;
            Dex    = new EXP[IO.ReadInt32()];
            int DEXOffset = IO.ReadInt32();

            if (IO.ReadInt32() == 0x00)
            {
                Header.Format = Main.Format.X;
            }
            int DEXNameOffset = IO.ReadInt32();

            if (Header.IsX)
            {
                IO.ReadInt32();
            }

            IO.Seek(DEXOffset + Offset, 0);
            for (int i0 = 0; i0 < Dex.Length; i0++)
            {
                Dex[i0] = new EXP {
                    Main = new List <EXPElement>(), Eyes = new List <EXPElement>()
                }
            }
            ;

            for (int i0 = 0; i0 < Dex.Length; i0++)
            {
                Dex[i0].MainOffset = IO.ReadInt32();
                if (Header.IsX)
                {
                    IO.ReadInt32();
                }
                Dex[i0].EyesOffset = IO.ReadInt32();
                if (Header.IsX)
                {
                    IO.ReadInt32();
                }
            }
            IO.Seek(DEXNameOffset + Offset, 0);
            for (int i0 = 0; i0 < Dex.Length; i0++)
            {
                Dex[i0].NameOffset = IO.ReadInt32();
                if (Header.IsX)
                {
                    IO.ReadInt32();
                }
            }

            for (int i0 = 0; i0 < Dex.Length; i0++)
            {
                EXPElement element = new EXPElement();
                IO.Seek(Dex[i0].MainOffset + Offset, 0);
                while (true)
                {
                    element.Frame = IO.ReadSingle();
                    element.Both  = IO.ReadUInt16();
                    element.ID    = IO.ReadUInt16();
                    element.Value = IO.ReadSingle();
                    element.Trans = IO.ReadSingle();
                    Dex[i0].Main.Add(element);

                    if (element.Frame == 999999 || element.Both == 0xFFFF)
                    {
                        break;
                    }
                }

                IO.Seek(Dex[i0].EyesOffset + Offset, 0);
                while (true)
                {
                    element.Frame = IO.ReadSingle();
                    element.Both  = IO.ReadUInt16();
                    element.ID    = IO.ReadUInt16();
                    element.Value = IO.ReadSingle();
                    element.Trans = IO.ReadSingle();
                    Dex[i0].Eyes.Add(element);

                    if (element.Frame == 999999 || element.Both == 0xFFFF)
                    {
                        break;
                    }
                }

                IO.Seek(Dex[i0].NameOffset + Offset, 0);
                Dex[i0].Name = IO.NullTerminatedUTF8();
            }

            IO.Close();
            return(1);
        }
Example #4
0
        public int DEXReader()
        {
            KKtIO reader = KKtIO.OpenReader(filepath + ext);

            Header = new KKtMain.Header();

            Header.Format    = KKtMain.Format.F;
            Header.Signature = reader.ReadInt32();
            if (Header.Signature == 0x43505845)
            {
                Header = reader.ReadHeader(true);
            }
            if (Header.Signature != 0x64)
            {
                return(0);
            }

            Offset = reader.Position - 0x4;
            DEX    = new EXP[reader.ReadInt32()];
            int DEXOffset = reader.ReadInt32();

            if (reader.ReadInt32() == 0x00)
            {
                Header.Format = KKtMain.Format.X;
            }

            reader.Seek(DEXOffset + Offset, 0);
            for (int i0 = 0; i0 < DEX.Length; i0++)
            {
                DEX[i0] = new EXP {
                    Main = new List <EXPElement>(), Eyes = new List <EXPElement>()
                }
            }
            ;

            for (int i0 = 0; i0 < DEX.Length; i0++)
            {
                DEX[i0].MainOffset = reader.ReadInt32();
                if (Header.Format == KKtMain.Format.X)
                {
                    reader.ReadInt32();
                }
                DEX[i0].EyesOffset = reader.ReadInt32();
                if (Header.Format == KKtMain.Format.X)
                {
                    reader.ReadInt32();
                }
            }
            for (int i0 = 0; i0 < DEX.Length; i0++)
            {
                DEX[i0].NameOffset = reader.ReadInt32();
                if (Header.Format == KKtMain.Format.X)
                {
                    reader.ReadInt32();
                }
            }

            for (int i0 = 0; i0 < DEX.Length; i0++)
            {
                EXPElement element = new EXPElement();
                reader.Seek(DEX[i0].MainOffset + Offset, 0);
                while (true)
                {
                    element.Frame = reader.ReadSingle();
                    element.Both  = reader.ReadUInt16();
                    element.ID    = reader.ReadUInt16();
                    element.Value = reader.ReadSingle();
                    element.Trans = reader.ReadSingle();
                    DEX[i0].Main.Add(element);

                    if (element.Frame == 999999 || element.Both == 0xFFFF)
                    {
                        break;
                    }
                }

                reader.Seek(DEX[i0].EyesOffset + Offset, 0);
                while (true)
                {
                    element.Frame = reader.ReadSingle();
                    element.Both  = reader.ReadUInt16();
                    element.ID    = reader.ReadUInt16();
                    element.Value = reader.ReadSingle();
                    element.Trans = reader.ReadSingle();
                    DEX[i0].Eyes.Add(element);

                    if (element.Frame == 999999 || element.Both == 0xFFFF)
                    {
                        break;
                    }
                }

                reader.Seek(DEX[i0].NameOffset + Offset, 0);
                DEX[i0].Name = KKtText.ToUTF8(reader.NullTerminated());
            }

            reader.Close();
            return(1);
        }
Example #5
0
        public void XMLReader()
        {
            DEX    = new EXP[0];
            Header = new KKtMain.Header();

            KKtXml Xml = new KKtXml();

            Xml.OpenXml(filepath + ".xml", true);
            Xml.Compact = true;
            int i = 0;

            foreach (XElement DEX_ in Xml.doc.Elements("DEX"))
            {
                foreach (XAttribute Entry in DEX_.Attributes())
                {
                    if (Entry.Name == "Format")
                    {
                        Enum.TryParse(Entry.Value, out Header.Format);
                    }
                    else if (Entry.Name == "Length")
                    {
                        DEX = new EXP[int.Parse(Entry.Value)];
                    }
                }
                foreach (XElement EXP in DEX_.Elements())
                {
                    if (EXP.Name != "EXP")
                    {
                        continue;
                    }

                    DEX[i] = new EXP {
                        Main = new List <EXPElement>(), Eyes = new List <EXPElement>()
                    };
                    foreach (XAttribute Entry in EXP.Attributes())
                    {
                        if (Entry.Name == "Name")
                        {
                            DEX[i].Name = Entry.Value;
                        }
                    }
                    foreach (XElement EXPElement in EXP.Elements())
                    {
                        if (EXPElement.Name == "Main" || EXPElement.Name == "Eyes")
                        {
                            foreach (XElement Element in EXPElement.Elements())
                            {
                                if (Element.Name != "Element")
                                {
                                    continue;
                                }

                                EXPElement element = new EXPElement();
                                foreach (XAttribute Entry in Element.Attributes())
                                {
                                    if (Entry.Name == "Frame")
                                    {
                                        element.Frame = KKtMain.ToDouble(Entry.Value);
                                    }
                                    if (Entry.Name == "Both")
                                    {
                                        element.Both = ushort.Parse(Entry.Value);
                                    }
                                    if (Entry.Name == "ID")
                                    {
                                        element.ID = ushort.Parse(Entry.Value);
                                    }
                                    if (Entry.Name == "Value")
                                    {
                                        element.Value = KKtMain.ToDouble(Entry.Value);
                                    }
                                    if (Entry.Name == "Trans")
                                    {
                                        element.Trans = KKtMain.ToDouble(Entry.Value);
                                    }
                                }
                                if (EXPElement.Name == "Main")
                                {
                                    DEX[i].Main.Add(element);
                                }
                                else if (EXPElement.Name == "Eyes")
                                {
                                    DEX[i].Eyes.Add(element);
                                }
                            }
                        }
                    }
                    i++;
                }
            }
        }
Example #6
0
        public void DEXReader(string filepath, string ext)
        {
            Dex    = null;
            header = new Header();
            _IO    = File.OpenReader(filepath + ext);

            header.Format           = Format.F;
            header.SectionSignature = _IO.RI32();
            if (header.SectionSignature == 0x43505845)
            {
                header = _IO.ReadHeader(true, true);
            }
            if (header.SectionSignature != 0x64)
            {
                return;
            }

            _IO.O = _IO.P - 0x4;
            Dex   = new EXP[_IO.RI32()];
            int DEXOffset     = _IO.RI32();
            int DEXNameOffset = _IO.RI32();

            if (DEXNameOffset == 0x00)
            {
                _IO.Format = header.Format = Format.X; DEXNameOffset = (int)_IO.RIX();
            }

            _IO.P = DEXOffset;
            for (i = 0; i < Dex.Length; i++)
            {
                Dex[i].MainOffset = (int)_IO.RIX();
                Dex[i].EyesOffset = (int)_IO.RIX();
            }
            _IO.P = DEXNameOffset;
            for (i = 0; i < Dex.Length; i++)
            {
                Dex[i].NameOffset = (int)_IO.RIX();
            }

            for (i = 0; i < Dex.Length; i++)
            {
                EXPElement element = new EXPElement();
                Dex[i].Main = KKdList <EXPElement> .New;
                _IO.P       = Dex[i].MainOffset;
                while (true)
                {
                    element.Frame = _IO.RF32();
                    element.Both  = _IO.RU16();
                    element.ID    = _IO.RU16();
                    element.Value = _IO.RF32();
                    element.Trans = _IO.RF32();
                    if (element.Frame == 999999 || element.Both == 0xFFFF)
                    {
                        break;
                    }
                    Dex[i].Main.Add(element);
                }

                Dex[i].Eyes = KKdList <EXPElement> .New;
                _IO.P       = Dex[i].EyesOffset;
                while (true)
                {
                    element.Frame = _IO.RF32();
                    element.Both  = _IO.RU16();
                    element.ID    = _IO.RU16();
                    element.Value = _IO.RF32();
                    element.Trans = _IO.RF32();
                    if (element.Frame == 999999 || element.Both == 0xFFFF)
                    {
                        break;
                    }
                    Dex[i].Eyes.Add(element);
                }

                Dex[i].Name = _IO.RSaO(Dex[i].NameOffset);
            }

            _IO.C();
        }
Example #7
0
        public void DEXReader(string filepath, string ext)
        {
            Dex    = null;
            header = new Header();
            s      = File.OpenReader(filepath + ext);

            header.Format = Format.F;
            uint signature = s.RU32();

            if (signature == 0x43505845)
            {
                header = s.ReadHeader(true); signature = s.RU32();
            }
            if (signature != 0x64)
            {
                return;
            }

            s.O = s.P - 0x4;
            Dex = new EXP[s.RI32()];
            int DEXOffset     = s.RI32();
            int DEXNameOffset = s.RI32();

            if (DEXNameOffset == 0x00)
            {
                s.Format = header.Format = Format.X; DEXNameOffset = (int)s.RIX();
            }

            s.P = DEXOffset;
            for (i = 0; i < Dex.Length; i++)
            {
                Dex[i].MainOffset = (int)s.RIX();
                Dex[i].EyesOffset = (int)s.RIX();
            }
            s.P = DEXNameOffset;
            for (i = 0; i < Dex.Length; i++)
            {
                Dex[i].NameOffset = (int)s.RIX();
            }

            for (i = 0; i < Dex.Length; i++)
            {
                EXPElement element = new EXPElement();
                Dex[i].Main = KKdList <EXPElement> .New;
                s.P         = Dex[i].MainOffset;
                while (true)
                {
                    element.Frame = s.RF32();
                    element.Both  = s.RU16();
                    element.ID    = s.RU16();
                    element.Value = s.RF32();
                    element.Trans = s.RF32();
                    if (element.Frame == 999999 || element.Both == 0xFFFF)
                    {
                        break;
                    }
                    Dex[i].Main.Add(element);
                }
                Dex[i].Main.Capacity = Dex[i].Main.Count;

                Dex[i].Eyes = KKdList <EXPElement> .New;
                s.P         = Dex[i].EyesOffset;
                while (true)
                {
                    element.Frame = s.RF32();
                    element.Both  = s.RU16();
                    element.ID    = s.RU16();
                    element.Value = s.RF32();
                    element.Trans = s.RF32();
                    if (element.Frame == 999999 || element.Both == 0xFFFF)
                    {
                        break;
                    }
                    Dex[i].Eyes.Add(element);
                }
                Dex[i].Eyes.Capacity = Dex[i].Eyes.Count;

                Dex[i].Name = s.RSaO(Dex[i].NameOffset);
            }

            s.C();
        }