Beispiel #1
0
        protected void SaveGuilds()
        {
            GenericWriter idx;
            GenericWriter bin;


            idx = new AsyncWriter(World.GuildIndexPath, false);
            bin = new AsyncWriter(World.GuildDataPath, true);


            idx.Write((int)BaseGuild.List.Count);
            foreach (BaseGuild guild in BaseGuild.List.Values)
            {
                long start = bin.Position;

                idx.Write((int)0);//guilds have no typeid
                idx.Write((int)guild.Id);
                idx.Write((long)start);

                guild.Serialize(bin);


                idx.Write((int)(bin.Position - start));
            }

            idx.Close();
            bin.Close();
        }
Beispiel #2
0
        private static void SaveRegions()
        {
            GenericWriter writer1;
            int           num2;
            Region        region1;
            long          num3;
            AsyncWriter   writer3;
            int           num1 = 0;

            if (World.SaveType == SaveOption.Normal)
            {
                writer1 = new BinaryFileWriter(World.regionBinPath, true);
            }
            else
            {
                writer1 = new AsyncWriter(World.regionBinPath, true);
            }
            MemoryStream stream1 = new MemoryStream((4 + (20 * Region.Regions.Count)));
            BinaryWriter writer2 = new BinaryWriter(stream1);

            writer2.Write(0);
            for (num2 = 0; (num2 < Region.Regions.Count); ++num2)
            {
                region1 = ((Region)Region.Regions[num2]);
                if (region1.Saves)
                {
                    ++num1;
                    num3 = writer1.Position;
                    writer2.Write(0);
                    writer2.Write(region1.UId);
                    writer2.Write(num3);
                    region1.Serialize(writer1);
                    writer2.Write(((int)(writer1.Position - num3)));
                }
            }
            writer1.Close();
            writer2.Seek(0, SeekOrigin.Begin);
            writer2.Write(num1);
            if (World.SaveType == SaveOption.Threaded)
            {
                writer3           = new AsyncWriter(World.regionIdxPath, false);
                writer3.MemStream = stream1;
                writer3.Close();
                return;
            }
            FileStream stream2 = new FileStream(World.regionIdxPath, FileMode.Create, FileAccess.Write, FileShare.None);

            stream1.WriteTo(stream2);
            stream2.Close();
        }
Beispiel #3
0
        private static void SaveRegions(string regionBase)
        {
            string regionIdxPath = Path.Combine( regionBase, "Regions.idx" );
            string regionBinPath = Path.Combine( regionBase, "Regions.bin" );

            int count = 0;

            GenericWriter bin;

            if (!Directory.Exists(regionBase))
                Directory.CreateDirectory(regionBase);

            if ( SaveType == SaveOption.Normal )
                bin = new BinaryFileWriter( regionBinPath, true );
            else
                bin = new AsyncWriter( regionBinPath, true );

            MemoryStream mem = new MemoryStream( 4 + (20*Region.Regions.Count) );
            BinaryWriter memIdx = new BinaryWriter( mem );

            memIdx.Write( (int)0 );

            for ( int i = 0; i < Region.Regions.Count; ++i )
            {
                Region region = (Region)Region.Regions[i];

                if ( region.Saves )
                {
                    ++count;
                    long start = bin.Position;

                    memIdx.Write( (int)0 );//typeid
                    memIdx.Write( (int) region.UId );
                    memIdx.Write( (long) start );

                    region.Serialize( bin );

                    memIdx.Write( (int) (bin.Position - start) );
                }
            }

            bin.Close();

            memIdx.Seek( 0, SeekOrigin.Begin );
            memIdx.Write( (int)count );

            if ( SaveType == SaveOption.Threaded )
            {
                AsyncWriter asyncIdx = new AsyncWriter( regionIdxPath, false );
                asyncIdx.MemStream = mem;
                asyncIdx.Close();
            }
            else
            {
                FileStream fs = new FileStream( regionIdxPath, FileMode.Create, FileAccess.Write, FileShare.None );
                mem.WriteTo( fs );
                fs.Close();
                mem.Close();
            }

            // mem is closed only in non threaded saves, as its reference is copied to asyncIdx.MemStream
            memIdx.Close();
        }
Beispiel #4
0
        private static void SaveRegions()
        {
            int count = 0;

            GenericWriter bin;

            if (SaveType == SaveOption.Normal)
            {
                bin = new BinaryFileWriter(regionBinPath, true);
            }
            else
            {
                bin = new AsyncWriter(regionBinPath, true);
            }

            MemoryStream mem    = new MemoryStream(4 + (20 * Region.Regions.Count));
            BinaryWriter memIdx = new BinaryWriter(mem);

            memIdx.Write((int)0);

            for (int i = 0; i < Region.Regions.Count; ++i)
            {
                Region region = (Region)Region.Regions[i];

                if (region.Saves)
                {
                    ++count;
                    long start = bin.Position;

                    memIdx.Write((int)0);                      //typeid
                    memIdx.Write((int)region.UId);
                    memIdx.Write((long)start);

                    region.Serialize(bin);

                    memIdx.Write((int)(bin.Position - start));
                }
            }

            bin.Close();

            memIdx.Seek(0, SeekOrigin.Begin);
            memIdx.Write((int)count);

            if (SaveType == SaveOption.Threaded)
            {
                AsyncWriter asyncIdx = new AsyncWriter(regionIdxPath, false);
                asyncIdx.MemStream = mem;
                asyncIdx.Close();
            }
            else
            {
                FileStream fs = new FileStream(regionIdxPath, FileMode.Create, FileAccess.Write, FileShare.None);
                mem.WriteTo(fs);
                fs.Close();
                mem.Close();
            }

            // mem is closed only in non threaded saves, as its reference is copied to asyncIdx.MemStream
            memIdx.Close();
        }