示例#1
0
        /// <summary>
        /// Load the specified ROPT file (in plain format) into the dictionary.
        /// </summary>
        public void LoadFromTxt(String Path)
        {
            Clear();

            lock (Parts)
                lock (Dumies)
                {
                    Ini Ini = new Ini(Path);

                    Int32 PartAmount = Ini.ReadInt32("Config", "Count");
                    Int32 DumyAmount = Int32.Parse(Ini.ReadValue("Dumy", "Count").TrimEnd('¡'));

                    Byte *pStr = stackalloc Byte[Kernel.MAX_BUFFER_SIZE];

                    for (Int32 i = 0; i < PartAmount; i++)
                    {
                        String Name      = Ini.ReadValue("Config", "Part" + i);
                        String MeshIni   = Ini.ReadValue("Config", "MeshIni" + i);
                        String MotionIni = Ini.ReadValue("Config", "MotionIni" + i);

                        Part *pPart = (Part *)Kernel.calloc(sizeof(Part));

                        Name.ToPointer(pStr);
                        Kernel.memcpy(pPart->Name, pStr, Math.Min(MAX_NAMESIZE - 1, Kernel.strlen(pStr)));
                        MeshIni.ToPointer(pStr);
                        Kernel.memcpy(pPart->MeshIni, pStr, Math.Min(MAX_PATHSIZE - 1, Kernel.strlen(pStr)));
                        MotionIni.ToPointer(pStr);
                        Kernel.memcpy(pPart->MotionIni, pStr, Math.Min(MAX_PATHSIZE - 1, Kernel.strlen(pStr)));

                        if (!Parts.ContainsKey(Kernel.cstring(pPart->Name, MAX_NAMESIZE)))
                        {
                            Parts.Add(Kernel.cstring(pPart->Name, MAX_NAMESIZE), (IntPtr)pPart);
                        }
                    }

                    for (Int32 i = 0; i < DumyAmount; i++)
                    {
                        String Name = Ini.ReadValue("Dumy", "Dumy" + i) + "\0";

                        Dumy *pDumy = (Dumy *)Kernel.calloc(sizeof(Dumy));
                        pDumy->UniqId = i;

                        Name.ToPointer(pStr);
                        Kernel.memcpy(pDumy->Name, pStr, Math.Min(MAX_NAMESIZE - 1, Kernel.strlen(pStr)));

                        if (!Dumies.ContainsKey(pDumy->UniqId))
                        {
                            Dumies.Add(pDumy->UniqId, (IntPtr)pDumy);
                        }
                    }
                }
        }
示例#2
0
        /// <summary>
        /// Load the specified ROPT file (in binary format) into the dictionary.
        /// </summary>
        public void LoadFromDat(String Path)
        {
            Clear();

            lock (Parts)
                lock (Dumies)
                {
                    using (FileStream Stream = new FileStream(Path, FileMode.Open, FileAccess.Read, FileShare.Read))
                    {
                        Byte[]  Buffer  = new Byte[Kernel.MAX_BUFFER_SIZE];
                        Header *pHeader = stackalloc Header[1];

                        Stream.Read(Buffer, 0, sizeof(Header));
                        Kernel.memcpy(pHeader, Buffer, sizeof(Header));

                        if (pHeader->Identifier != ROPT_IDENTIFIER)
                        {
                            throw new Exception("Invalid ROPT Header in file: " + Path);
                        }

                        for (Int32 i = 0; i < pHeader->PartAmount; i++)
                        {
                            Part *pPart = (Part *)Kernel.malloc(sizeof(Part));
                            Stream.Read(Buffer, 0, sizeof(Part));
                            Kernel.memcpy(pPart, Buffer, sizeof(Part));

                            if (!Parts.ContainsKey(Kernel.cstring(pPart->Name, MAX_NAMESIZE)))
                            {
                                Parts.Add(Kernel.cstring(pPart->Name, MAX_NAMESIZE), (IntPtr)pPart);
                            }
                        }

                        for (Int32 i = 0; i < pHeader->DumyAmount; i++)
                        {
                            Dumy *pDumy = (Dumy *)Kernel.malloc(sizeof(Dumy));
                            Stream.Read(Buffer, 0, sizeof(Dumy));
                            Kernel.memcpy(pDumy, Buffer, sizeof(Dumy));

                            if (!Dumies.ContainsKey(pDumy->UniqId))
                            {
                                Dumies.Add(pDumy->UniqId, (IntPtr)pDumy);
                            }
                        }
                    }
                }
        }
示例#3
0
        /// <summary>
        /// Save all the dictionary to the specified ROPT file (in binary format).
        /// </summary>
        public void SaveToDat(String Path)
        {
            using (FileStream Stream = new FileStream(Path, FileMode.Create, FileAccess.ReadWrite, FileShare.Read))
            {
                lock (Parts)
                    lock (Dumies)
                    {
                        Byte[]   Buffer   = new Byte[Kernel.MAX_BUFFER_SIZE];
                        IntPtr[] Pointers = new IntPtr[0];

                        Header *pHeader = stackalloc Header[1];
                        pHeader->Identifier = ROPT_IDENTIFIER;
                        pHeader->PartAmount = Parts.Count;
                        pHeader->DumyAmount = Dumies.Count;

                        Kernel.memcpy(Buffer, pHeader, sizeof(Header));
                        Stream.Write(Buffer, 0, sizeof(Header));

                        Pointers = new IntPtr[Parts.Count];
                        Parts.Values.CopyTo(Pointers, 0);

                        for (Int32 i = 0; i < Pointers.Length; i++)
                        {
                            Part *pPart = (Part *)Pointers[i];
                            Kernel.memcpy(Buffer, pPart, sizeof(Part));
                            Stream.Write(Buffer, 0, sizeof(Part));
                        }

                        Pointers = new IntPtr[Dumies.Count];
                        Dumies.Values.CopyTo(Pointers, 0);

                        for (Int32 i = 0; i < Pointers.Length; i++)
                        {
                            Dumy *pDumy = (Dumy *)Pointers[i];
                            Kernel.memcpy(Buffer, pDumy, sizeof(Dumy));
                            Stream.Write(Buffer, 0, sizeof(Dumy));
                        }
                    }
            }
        }
示例#4
0
        /// <summary>
        /// Save all the dictionary to the specified ROPT file (in plain format).
        /// </summary>
        public void SaveToTxt(String Path)
        {
            using (StreamWriter Stream = new StreamWriter(Path, false, Encoding.GetEncoding("Windows-1252")))
            {
                lock (Parts)
                    lock (Dumies)
                    {
                        IntPtr[] Pointers = new IntPtr[0];

                        Pointers = new IntPtr[Parts.Count];
                        Parts.Values.CopyTo(Pointers, 0);

                        Stream.WriteLine("[Config]");
                        Stream.WriteLine("Count={0}", Parts.Count);
                        for (Int32 i = 0; i < Pointers.Length; i++)
                        {
                            Part *pPart = (Part *)Pointers[i];

                            Stream.WriteLine("Part{0}={1}", i, Kernel.cstring(pPart->Name, MAX_NAMESIZE));
                            Stream.WriteLine("MeshIni{0}={1}", i, Kernel.cstring(pPart->MeshIni, MAX_PATHSIZE));
                            Stream.WriteLine("MotionIni{0}={1}", i, Kernel.cstring(pPart->MotionIni, MAX_PATHSIZE));
                        }
                        Stream.WriteLine();

                        Pointers = new IntPtr[Dumies.Count];
                        Dumies.Values.CopyTo(Pointers, 0);

                        Stream.WriteLine("[Dumy]");
                        Stream.WriteLine("Count={0}¡¡¡¡¡¡", Dumies.Count);
                        for (Int32 i = 0; i < Pointers.Length; i++)
                        {
                            Dumy *pDumy = (Dumy *)Pointers[i];

                            Stream.WriteLine("Dumy{0}={1}", i, Kernel.cstring(pDumy->Name, MAX_NAMESIZE));
                        }
                    }
            }
        }