public override void Save( SaveMetrics metrics )
{
SaveMobiles( metrics );
SaveItems( metrics );
SaveGuilds( metrics );
SaveMaps( metrics );
}
protected void SaveGuilds( SaveMetrics metrics )
{
GenericWriter idx;
GenericWriter bin;
if ( World.SaveType == World.SaveOption.Normal ) {
idx = new BinaryFileWriter( World.GuildIndexPath, false );
bin = new BinaryFileWriter( World.GuildDataPath, true );
} else {
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 );
if ( metrics != null ) {
metrics.OnGuildSaved( ( int ) ( bin.Position - start ) );
}
idx.Write( ( int ) ( bin.Position - start ) );
}
idx.Close();
bin.Close();
}
public override void Save(SaveMetrics metrics, bool permitBackgroundWrite)
{
_metrics = metrics;
OpenFiles();
var saveTasks = new Task[4];
saveTasks[0] = SaveItems();
saveTasks[1] = SaveMobiles();
saveTasks[2] = SaveGuilds();
saveTasks[3] = SaveData();
SaveTypeDatabases();
if (permitBackgroundWrite)
{
//This option makes it finish the writing to disk in the background, continuing even after Save() returns.
Task.Factory.ContinueWhenAll(
saveTasks,
_ =>
{
CloseFiles();
World.NotifyDiskWriteComplete();
});
}
else
{
Task.WaitAll(saveTasks); //Waits for the completion of all of the tasks(committing to disk)
CloseFiles();
}
}
public override void Save(SaveMetrics metrics, bool permitBackgroundWrite)
{
_metrics = metrics;
OpenFiles();
var saveTasks = new Task[3];
saveTasks[0] = SaveItems();
saveTasks[1] = SaveMobiles();
saveTasks[2] = SaveGuilds();
SaveTypeDatabases();
if (permitBackgroundWrite)
{
//This option makes it finish the writing to disk in the background, continuing even after Save() returns.
Task.Factory.ContinueWhenAll(
saveTasks,
_ =>
{
CloseFiles();
World.NotifyDiskWriteComplete();
});
}
else
{
Task.WaitAll(saveTasks); //Waits for the completion of all of the tasks(committing to disk)
CloseFiles();
}
}
public override void Save( SaveMetrics metrics, bool permitBackgroundWrite )
{
this.PermitBackgroundWrite = permitBackgroundWrite;
#if Framework_4_0
Task saveItemsTask = Task.Factory.StartNew(() => SaveItems(metrics));
#else
Thread saveThread = new Thread( delegate() {
SaveItems(metrics);
} );
saveThread.Name = "Item Save Subset";
saveThread.Start();
#endif
SaveMobiles( metrics );
SaveGuilds( metrics );
SaveMaps( metrics );
#if Framework_4_0
saveItemsTask.Wait();
#else
saveThread.Join();
#endif
if (permitBackgroundWrite && UseSequentialWriters) //If we're permitted to write in the background, but we don't anyways, then notify.
World.NotifyDiskWriteComplete();
}
public override void Save(SaveMetrics metrics, bool permitBackgroundWrite)
{
this.SaveMobiles();
this.SaveItemsSQL();
//this.SaveItems();
this.SaveGuilds();
this.SaveData();
}
protected void SaveItems(SaveMetrics metrics)
{
Dictionary <Serial, Item> items = World.Items;
GenericWriter idx;
GenericWriter tdb;
GenericWriter bin;
if (UseSequentialWriters)
{
idx = new BinaryFileWriter(World.ItemIndexPath, false);
tdb = new BinaryFileWriter(World.ItemTypesPath, false);
bin = new BinaryFileWriter(World.ItemDataPath, true);
}
else
{
idx = new AsyncWriter(World.ItemIndexPath, false);
tdb = new AsyncWriter(World.ItemTypesPath, false);
bin = new AsyncWriter(World.ItemDataPath, true);
}
idx.Write(( int )items.Count);
foreach (Item item in items.Values)
{
if (item.Decays && item.Parent == null && item.Map != Map.Internal && (item.LastMoved + item.DecayTime) <= DateTime.UtcNow)
{
_decayQueue.Enqueue(item);
}
long start = bin.Position;
idx.Write(( int )item.m_TypeRef);
idx.Write(( int )item.Serial);
idx.Write(( long )start);
item.Serialize(bin);
if (metrics != null)
{
metrics.OnItemSaved(( int )(bin.Position - start));
}
idx.Write(( int )(bin.Position - start));
item.FreeCache();
}
tdb.Write(( int )World.m_ItemTypes.Count);
for (int i = 0; i < World.m_ItemTypes.Count; ++i)
{
tdb.Write(World.m_ItemTypes[i].FullName);
}
idx.Close();
tdb.Close();
bin.Close();
}
protected void SaveMaps(SaveMetrics metrics)
{
Dictionary <Serial, BaseInstanceMap> maps = World.Maps;
GenericWriter idx;
GenericWriter tdb;
GenericWriter bin;
if (UseSequentialWriters)
{
idx = new BinaryFileWriter(World.MapIndexPath, false);
tdb = new BinaryFileWriter(World.MapTypesPath, false);
bin = new BinaryFileWriter(World.MapDataPath, true);
}
else
{
idx = new AsyncWriter(World.MapIndexPath, false);
tdb = new AsyncWriter(World.MapTypesPath, false);
bin = new AsyncWriter(World.MapDataPath, true);
}
idx.Write(( int )maps.Count);
foreach (BaseInstanceMap map in maps.Values)
{
if (map.Decays)
{
_decayMapQueue.Enqueue(map);
}
long start = bin.Position;
idx.Write(( int )map.TypeReference);
idx.Write(( int )map.Serial);
idx.Write(( long )start);
map.Serialize(bin);
if (metrics != null)
{
metrics.OnMapSaved(( int )(bin.Position - start));
}
idx.Write(( int )(bin.Position - start));
}
tdb.Write(( int )World.m_InstanceMapTypes.Count);
for (int i = 0; i < World.m_InstanceMapTypes.Count; ++i)
{
tdb.Write(World.m_InstanceMapTypes[i].FullName);
}
idx.Close();
tdb.Close();
bin.Close();
}
protected void SaveMobiles(SaveMetrics metrics)
{
Dictionary<Serial, Mobile> mobiles = World.Mobiles;
GenericWriter idx;
GenericWriter tdb;
GenericWriter bin;
if (UseSequentialWriters)
{
idx = new BinaryFileWriter(World.MobileIndexPath, false);
tdb = new BinaryFileWriter(World.MobileTypesPath, false);
bin = new BinaryFileWriter(World.MobileDataPath, true);
}
else
{
idx = new AsyncWriter(World.MobileIndexPath, false);
tdb = new AsyncWriter(World.MobileTypesPath, false);
bin = new AsyncWriter(World.MobileDataPath, true);
}
idx.Write(mobiles.Count);
foreach (Mobile m in mobiles.Values)
{
long start = bin.Position;
idx.Write(m._TypeRef);
idx.Write(m.Serial);
idx.Write(start);
m.Serialize(bin);
if (metrics != null)
{
metrics.OnMobileSaved((int)(bin.Position - start));
}
idx.Write((int)(bin.Position - start));
m.FreeCache();
}
tdb.Write(World.m_MobileTypes.Count);
foreach (Type t in World.m_MobileTypes)
{
tdb.Write(t.FullName);
}
idx.Close();
tdb.Close();
bin.Close();
}
protected void SaveMobiles(SaveMetrics metrics)
{
Dictionary <Serial, Mobile> mobiles = World.Mobiles;
GenericWriter idx;
GenericWriter tdb;
GenericWriter bin;
if (UseSequentialWriters)
{
idx = new BinaryFileWriter(World.MobileIndexPath, false);
tdb = new BinaryFileWriter(World.MobileTypesPath, false);
bin = new BinaryFileWriter(World.MobileDataPath, true);
}
else
{
idx = new AsyncWriter(World.MobileIndexPath, false);
tdb = new AsyncWriter(World.MobileTypesPath, false);
bin = new AsyncWriter(World.MobileDataPath, true);
}
idx.Write(( int )mobiles.Count);
foreach (Mobile m in mobiles.Values)
{
long start = bin.Position;
idx.Write(( int )m.m_TypeRef);
idx.Write(( int )m.Serial);
idx.Write(( long )start);
m.Serialize(bin);
if (metrics != null)
{
metrics.OnMobileSaved(( int )(bin.Position - start));
}
idx.Write(( int )(bin.Position - start));
m.FreeCache();
}
tdb.Write(( int )World.m_MobileTypes.Count);
for (int i = 0; i < World.m_MobileTypes.Count; ++i)
{
tdb.Write(World.m_MobileTypes[i].FullName);
}
idx.Close();
tdb.Close();
bin.Close();
}
public override void Save(SaveMetrics metrics, bool permitBackgroundWrite)
{
_permitBackgroundWrite = permitBackgroundWrite;
SaveMobiles(metrics);
SaveItems(metrics);
SaveGuilds(metrics);
if (permitBackgroundWrite && UseSequentialWriters) //If we're permitted to write in the background, but we don't anyways, then notify.
World.NotifyDiskWriteComplete();
}
public override void Save(SaveMetrics metrics)
{
this.metrics = metrics;
OpenFiles();
consumers = new Consumer[GetThreadCount()];
for (int i = 0; i < consumers.Length; ++i)
{
consumers[i] = new Consumer(this, 256);
}
IEnumerable <ISerializable> collection = new Producer();
foreach (ISerializable value in collection)
{
while (!Enqueue(value))
{
if (!Commit())
{
Thread.Sleep(0);
}
}
}
finished = true;
SaveTypeDatabases();
WaitHandle.WaitAll(
Array.ConvertAll <Consumer, WaitHandle>(
consumers,
delegate(Consumer input) {
return(input.completionEvent);
}
)
);
Commit();
CloseFiles();
if (decaying != null)
{
foreach (Item item in decaying)
{
if (item.OnDecay())
{
item.Delete();
}
}
}
}
public override void Save(SaveMetrics metrics, bool permitBackgroundWrite)
{
_permitBackgroundWrite = permitBackgroundWrite;
SaveMobiles(metrics);
SaveItems(metrics);
if (permitBackgroundWrite && UseSequentialWriters) //If we're permitted to write in the background, but we don't anyways, then notify.
{
World.NotifyDiskWriteComplete();
}
}
protected void SaveData(SaveMetrics metrics)
{
Dictionary <CustomSerial, SaveData> data = World.Data;
GenericWriter indexWriter;
GenericWriter typeWriter;
GenericWriter dataWriter;
if (UseSequentialWriters)
{
indexWriter = new BinaryFileWriter(World.DataIndexPath, false);
typeWriter = new BinaryFileWriter(World.DataTypesPath, false);
dataWriter = new BinaryFileWriter(World.DataBinaryPath, true);
}
else
{
indexWriter = new AsyncWriter(World.DataIndexPath, false);
typeWriter = new AsyncWriter(World.DataTypesPath, false);
dataWriter = new AsyncWriter(World.DataBinaryPath, true);
}
indexWriter.Write(data.Count);
foreach (SaveData saveData in data.Values)
{
long start = dataWriter.Position;
indexWriter.Write(saveData._TypeID);
indexWriter.Write(saveData.Serial);
indexWriter.Write(start);
saveData.Serialize(dataWriter);
if (metrics != null)
{
metrics.OnDataSaved((int)(dataWriter.Position - start));
}
indexWriter.Write((int)(dataWriter.Position - start));
}
typeWriter.Write(World._DataTypes.Count);
foreach (Type t in World._DataTypes)
{
typeWriter.Write(t.FullName);
}
indexWriter.Close();
typeWriter.Close();
dataWriter.Close();
}
public SequentialFileWriter(string path, SaveMetrics metrics)
{
if (path == null)
{
throw new ArgumentNullException("path");
}
this.metrics = metrics;
fileStream = FileOperations.OpenSequentialStream(path, FileMode.Create, FileAccess.Write, FileShare.None);
fileQueue = new FileQueue(Math.Max(1, FileOperations.Concurrency), FileCallback);
}
public override void Save( SaveMetrics metrics ) {
Thread saveThread = new Thread( delegate() {
SaveItems( metrics );
} );
saveThread.Name = "Item Save Subset";
saveThread.Start();
SaveMobiles( metrics );
SaveGuilds( metrics );
saveThread.Join();
}
public SequentialFileWriter(string path, SaveMetrics metrics)
{
if (path == null)
{
throw new ArgumentNullException("path");
}
this.metrics = metrics;
fileStream = FileOperations.OpenSequentialStream(path, FileMode.Create, FileAccess.Write, FileShare.None);
fileQueue = new FileQueue(Math.Max(1, FileOperations.Concurrency), FileCallback);
}
public override void Save(SaveMetrics metrics, bool permitBackgroundWrite)
{
PermitBackgroundWrite = permitBackgroundWrite;
SaveMobiles(metrics);
SaveItems(metrics);
SaveGuilds(metrics);
if (permitBackgroundWrite && UseSequentialWriters)
{
World.NotifyDiskWriteComplete();
}
}
public override void Save(SaveMetrics metrics)
{
Thread saveThread = new Thread(delegate() {
SaveItems(metrics);
});
saveThread.Name = "Item Save Subset";
saveThread.Start();
SaveMobiles(metrics);
SaveGuilds(metrics);
saveThread.Join();
}
protected void SaveMobiles( SaveMetrics metrics ) {
Dictionary<Serial, Mobile> mobiles = World.Mobiles;
GenericWriter idx;
GenericWriter tdb;
GenericWriter bin;
if ( World.SaveType == World.SaveOption.Normal ) {
idx = new BinaryFileWriter( World.MobileIndexPath, false );
tdb = new BinaryFileWriter( World.MobileTypesPath, false );
bin = new BinaryFileWriter( World.MobileDataPath, true );
} else {
idx = new AsyncWriter( World.MobileIndexPath, false );
tdb = new AsyncWriter( World.MobileTypesPath, false );
bin = new AsyncWriter( World.MobileDataPath, true );
}
idx.Write( ( int ) mobiles.Count );
foreach ( Mobile m in mobiles.Values ) {
long start = bin.Position;
idx.Write( ( int ) m.m_TypeRef );
idx.Write( ( int ) m.Serial );
idx.Write( ( long ) start );
m.Serialize( bin );
if ( metrics != null ) {
metrics.OnMobileSaved( ( int ) ( bin.Position - start ) );
}
idx.Write( ( int ) ( bin.Position - start ) );
m.FreeCache();
}
tdb.Write( ( int ) World.m_MobileTypes.Count );
for ( int i = 0; i < World.m_MobileTypes.Count; ++i )
tdb.Write( World.m_MobileTypes[i].FullName );
idx.Close();
tdb.Close();
bin.Close();
}
public override void Save( SaveMetrics metrics, bool permitBackgroundWrite )
{
this.PermitBackgroundWrite = permitBackgroundWrite;
Thread saveThread = new Thread( delegate() {
SaveItems(metrics);
} );
saveThread.Name = "Item Save Subset";
saveThread.Start();
SaveMobiles(metrics);
SaveGuilds(metrics);
saveThread.Join();
if (permitBackgroundWrite && UseSequentialWriters) //If we're permitted to write in the background, but we don't anyways, then notify.
World.NotifyDiskWriteComplete();
}
public override void Save(SaveMetrics metrics, bool permitBackgroundWrite)
{
this.metrics = metrics;
this.OpenFiles();
this.consumers = new Consumer[this.GetThreadCount()];
for (int i = 0; i < this.consumers.Length; ++i)
{
this.consumers[i] = new Consumer(this, 256);
}
IEnumerable <ISerializable> collection = new Producer();
foreach (ISerializable value in collection)
{
while (!this.Enqueue(value))
{
if (!this.Commit())
{
Thread.Sleep(0);
}
}
}
this.finished = true;
this.SaveTypeDatabases();
WaitHandle.WaitAll(
Array.ConvertAll <Consumer, WaitHandle>(
this.consumers,
delegate(Consumer input)
{
return(input.completionEvent);
}));
this.Commit();
this.CloseFiles();
}
public override void Save(SaveMetrics metrics, bool permitBackgroundWrite)
{
this.PermitBackgroundWrite = permitBackgroundWrite;
Thread saveThread = new Thread(delegate() {
SaveItems(metrics);
});
saveThread.Name = "Item Save Subset";
saveThread.Start();
SaveMobiles(metrics);
saveThread.Join();
if (permitBackgroundWrite && UseSequentialWriters) //If we're permitted to write in the background, but we don't anyways, then notify.
{
World.NotifyDiskWriteComplete();
}
}
protected void SaveGuilds(SaveMetrics metrics)
{
GenericWriter idx;
GenericWriter bin;
if (UseSequentialWriters)
{
idx = new BinaryFileWriter(World.GuildIndexPath, false);
bin = new BinaryFileWriter(World.GuildDataPath, true);
}
else
{
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);
if (metrics != null)
{
metrics.OnGuildSaved((int)(bin.Position - start));
}
idx.Write((int)(bin.Position - start));
}
idx.Close();
bin.Close();
}
public override void Save(SaveMetrics metrics, bool permitBackgroundWrite)
{
PermitBackgroundWrite = permitBackgroundWrite;
var saveThread = new Thread(() => SaveItems(metrics))
{
Name = "Item Save Subset"
};
saveThread.Start();
SaveMobiles(metrics);
SaveGuilds(metrics);
SaveData(metrics);
saveThread.Join();
if (permitBackgroundWrite && UseSequentialWriters)
{
//If we're permitted to write in the background, but we don't anyways, then notify.
World.NotifyDiskWriteComplete();
}
}
public override void Save(SaveMetrics m, bool permitBackgroundWrite)
{
metrics = m;
OpenFiles();
consumers = new Consumer[GetThreadCount()];
for (int i = 0; i < consumers.Length; ++i)
{
consumers[i] = new Consumer(this, 256);
}
IEnumerable <ISerializable> collection = new Producer();
foreach (ISerializable value in collection)
{
while (!Enqueue(value))
{
if (!Commit())
{
Thread.Sleep(0);
}
}
}
finished = true;
SaveTypeDatabases();
WaitHandle.WaitAll(Array.ConvertAll <Consumer, WaitHandle>(consumers, input => input.completionEvent));
Commit();
CloseFiles();
}
public override void Save(SaveMetrics metrics)
{
SaveMobiles(metrics);
SaveItems(metrics);
SaveGuilds(metrics);
}
protected void SaveServices(SaveMetrics metrics)
{
Dictionary<CustomSerial, BaseService> services = World.Services;
GenericWriter indexWriter;
GenericWriter typeWriter;
GenericWriter dataWriter;
if (this.UseSequentialWriters)
{
indexWriter = new BinaryFileWriter(World.ServiceIndexPath, false);
typeWriter = new BinaryFileWriter(World.ServiceTypesPath, false);
dataWriter = new BinaryFileWriter(World.ServicesDataPath, true);
}
else
{
indexWriter = new AsyncWriter(World.ServiceIndexPath, false);
typeWriter = new AsyncWriter(World.ServiceTypesPath, false);
dataWriter = new AsyncWriter(World.ServicesDataPath, true);
}
indexWriter.Write(services.Count);
foreach (BaseService service in services.Values)
{
long start = dataWriter.Position;
indexWriter.Write(service._TypeID);
indexWriter.Write((int)service.Serial);
indexWriter.Write(start);
service.Serialize(dataWriter);
if (metrics != null)
metrics.OnServiceSaved((int)(dataWriter.Position - start));
indexWriter.Write((int)(dataWriter.Position - start));
}
typeWriter.Write(World._ServiceTypes.Count);
for (int i = 0; i < World._ServiceTypes.Count; ++i)
typeWriter.Write(World._ServiceTypes[i].FullName);
indexWriter.Close();
typeWriter.Close();
dataWriter.Close();
}
public abstract void Save(SaveMetrics metrics);
protected void SaveMaps( SaveMetrics metrics )
{
Dictionary<Serial, BaseInstanceMap> maps = World.Maps;
GenericWriter idx;
GenericWriter tdb;
GenericWriter bin;
if (UseSequentialWriters)
{
idx = new BinaryFileWriter( World.MapIndexPath, false );
tdb = new BinaryFileWriter( World.MapTypesPath, false );
bin = new BinaryFileWriter( World.MapDataPath, true );
}
else
{
idx = new AsyncWriter( World.MapIndexPath, false );
tdb = new AsyncWriter( World.MapTypesPath, false );
bin = new AsyncWriter( World.MapDataPath, true );
}
idx.Write( ( int ) maps.Count );
foreach ( BaseInstanceMap map in maps.Values )
{
if ( map.Decays )
_decayMapQueue.Enqueue( map );
long start = bin.Position;
idx.Write( ( int ) map.TypeReference );
idx.Write( ( int ) map.Serial );
idx.Write( ( long ) start );
map.Serialize( bin );
if ( metrics != null )
metrics.OnMapSaved( ( int ) ( bin.Position - start ) );
idx.Write( ( int ) ( bin.Position - start ) );
}
tdb.Write( ( int ) World.m_InstanceMapTypes.Count );
for ( int i = 0; i < World.m_InstanceMapTypes.Count; ++i )
tdb.Write( World.m_InstanceMapTypes[i].FullName );
idx.Close();
tdb.Close();
bin.Close();
}
protected void SaveItems(SaveMetrics metrics)
{
Dictionary<Serial, Item> items = World.Items;
GenericWriter idx;
GenericWriter tdb;
GenericWriter bin;
if (UseSequentialWriters)
{
idx = new BinaryFileWriter( World.ItemIndexPath, false );
tdb = new BinaryFileWriter( World.ItemTypesPath, false );
bin = new BinaryFileWriter( World.ItemDataPath, true );
} else {
idx = new AsyncWriter( World.ItemIndexPath, false );
tdb = new AsyncWriter( World.ItemTypesPath, false );
bin = new AsyncWriter( World.ItemDataPath, true );
}
idx.Write( ( int ) items.Count );
foreach ( Item item in items.Values ) {
if ( item.Decays && item.Parent == null && item.Map != Map.Internal && ( item.LastMoved + item.DecayTime ) <= DateTime.Now ) {
_decayQueue.Enqueue( item );
}
long start = bin.Position;
idx.Write( ( int ) item.m_TypeRef );
idx.Write( ( int ) item.Serial );
idx.Write( ( long ) start );
item.Serialize( bin );
if ( metrics != null ) {
metrics.OnItemSaved( ( int ) ( bin.Position - start ) );
}
idx.Write( ( int ) ( bin.Position - start ) );
item.FreeCache();
}
tdb.Write( ( int ) World.m_ItemTypes.Count );
for ( int i = 0; i < World.m_ItemTypes.Count; ++i )
tdb.Write( World.m_ItemTypes[i].FullName );
idx.Close();
tdb.Close();
bin.Close();
}
public abstract void Save( SaveMetrics metrics );
public abstract void Save(SaveMetrics metrics, bool permitBackgroundWrite);
protected void SaveData(SaveMetrics metrics)
{
Dictionary<CustomSerial, SaveData> data = World.Data;
GenericWriter indexWriter;
GenericWriter typeWriter;
GenericWriter dataWriter;
if (this.UseSequentialWriters)
{
indexWriter = new BinaryFileWriter(World.DataIndexPath, false);
typeWriter = new BinaryFileWriter(World.DataTypesPath, false);
dataWriter = new BinaryFileWriter(World.DataBinaryPath, true);
}
else
{
indexWriter = new AsyncWriter(World.DataIndexPath, false);
typeWriter = new AsyncWriter(World.DataTypesPath, false);
dataWriter = new AsyncWriter(World.DataBinaryPath, true);
}
indexWriter.Write(data.Count);
foreach (SaveData saveData in data.Values)
{
long start = dataWriter.Position;
indexWriter.Write(saveData._TypeID);
indexWriter.Write((int)saveData.Serial);
indexWriter.Write(start);
saveData.Serialize(dataWriter);
if (metrics != null)
metrics.OnDataSaved((int)(dataWriter.Position - start));
indexWriter.Write((int)(dataWriter.Position - start));
}
typeWriter.Write(World._DataTypes.Count);
for (int i = 0; i < World._DataTypes.Count; ++i)
typeWriter.Write(World._DataTypes[i].FullName);
indexWriter.Close();
typeWriter.Close();
dataWriter.Close();
}
protected void SaveItems(SaveMetrics metrics)
{
Dictionary <Serial, Item> items = World.Items;
List <Item> decaying = new List <Item>();
GenericWriter idx;
GenericWriter tdb;
GenericWriter bin;
if (World.SaveType == World.SaveOption.Normal)
{
idx = new BinaryFileWriter(World.ItemIndexPath, false);
tdb = new BinaryFileWriter(World.ItemTypesPath, false);
bin = new BinaryFileWriter(World.ItemDataPath, true);
}
else
{
idx = new AsyncWriter(World.ItemIndexPath, false);
tdb = new AsyncWriter(World.ItemTypesPath, false);
bin = new AsyncWriter(World.ItemDataPath, true);
}
idx.Write(( int )items.Count);
foreach (Item item in items.Values)
{
if (item.Decays && item.Parent == null && item.Map != Map.Internal && (item.LastMoved + item.DecayTime) <= DateTime.Now)
{
decaying.Add(item);
}
long start = bin.Position;
idx.Write(( int )item.m_TypeRef);
idx.Write(( int )item.Serial);
idx.Write(( long )start);
item.Serialize(bin);
if (metrics != null)
{
metrics.OnItemSaved(( int )(bin.Position - start));
}
idx.Write(( int )(bin.Position - start));
item.FreeCache();
}
tdb.Write(( int )World.m_ItemTypes.Count);
for (int i = 0; i < World.m_ItemTypes.Count; ++i)
{
tdb.Write(World.m_ItemTypes[i].FullName);
}
idx.Close();
tdb.Close();
bin.Close();
for (int i = 0; i < decaying.Count; ++i)
{
Item item = decaying[i];
if (item.OnDecay())
{
item.Delete();
}
}
}
public override void Save(SaveMetrics metrics, bool permitBackgroundWrite)
{
using (Database.UODataContext writedb = new Database.UODataContext(Core.SQLConnect))
{
if (!(writedb.DatabaseExists()))
{
Console.WriteLine("No SQL db found, creating...");
writedb.CreateDatabase();
writedb.Dispose();
}
}
if (permitBackgroundWrite)
{
Parallel.Invoke(() =>
{
this.SaveMobiles();
}, () =>
{
this.SaveItemsSQL();
}, () =>
{
this.SaveGuildsSQL();
}, () =>
{
this.SaveDataSQL();
});
Console.WriteLine("Save Complete.");
World.BuffItems.Clear();
World.BuffMobiles.Clear();
World.BuffGuild.Clear();
}
else
{
Stopwatch watch = Stopwatch.StartNew();
World.BuffMobiles = new List <Mobile>();
World.BuffItems = new List <Item>();
World.BuffGuild = new List <BaseGuild>();
World.BuffSaveData = new List <CustomsFramework.SaveData>();
Console.WriteLine("");
Parallel.Invoke(() =>
{
foreach (Mobile m in World.Mobiles.Values)
{
World.BuffMobiles.Add(m);
}
}, () =>
{
foreach (Item i in World.Items.Values)
{
World.BuffItems.Add(i);
}
}, () =>
{
foreach (BaseGuild g in BaseGuild.List.Values)
{
World.BuffGuild.Add(g);
}
}, () =>
{
foreach (SaveData g in World.Data.Values)
{
World.BuffSaveData.Add(g);
}
});
Console.WriteLine("Buffer created: " + watch.Elapsed.TotalSeconds);
}
}
public static void Save(bool message, bool permitBackgroundWrite)
{
if (Saving)
{
return;
}
++m_Saves;
NetState.FlushAll();
NetState.Pause();
WaitForWriteCompletion(); //Blocks Save until current disk flush is done.
Saving = true;
m_DiskWriteHandle.Reset();
if (message)
{
Broadcast(0x35, false, AccessLevel.Player, "The world is saving, please wait.");
}
SaveStrategy strategy = SaveStrategy.Acquire();
Console.WriteLine("Core: Using {0} save strategy", strategy.Name.ToLowerInvariant());
Console.WriteLine("World: Saving...");
Stopwatch watch = Stopwatch.StartNew();
if (!Directory.Exists("Saves/Mobiles/"))
{
Directory.CreateDirectory("Saves/Mobiles/");
}
if (!Directory.Exists("Saves/Items/"))
{
Directory.CreateDirectory("Saves/Items/");
}
if (!Directory.Exists("Saves/Guilds/"))
{
Directory.CreateDirectory("Saves/Guilds/");
}
try
{
EventSink.InvokeBeforeWorldSave(new BeforeWorldSaveEventArgs());
}
catch (Exception e)
{
throw new Exception("FATAL: Exception in EventSink.BeforeWorldSave", e);
}
if (m_Metrics)
{
using (SaveMetrics metrics = new SaveMetrics())
strategy.Save(metrics, permitBackgroundWrite);
}
else
{
strategy.Save(null, permitBackgroundWrite);
}
try
{
EventSink.InvokeWorldSave(new WorldSaveEventArgs(message));
}
catch (Exception e)
{
throw new Exception("FATAL: Exception in EventSink.WorldSave", e);
}
watch.Stop();
Saving = false;
if (!permitBackgroundWrite)
{
NotifyDiskWriteComplete();
//Sets the DiskWriteHandle. If we allow background writes, we leave this upto the individual save strategies.
}
ProcessSafetyQueues();
strategy.ProcessDecay();
Console.WriteLine("Save finished in {0:F2} seconds.", watch.Elapsed.TotalSeconds);
if (message)
{
Broadcast(0x35, false, AccessLevel.Player, "World save done in {0:F1} seconds.", watch.Elapsed.TotalSeconds);
}
NetState.Resume();
try
{
EventSink.InvokeAfterWorldSave(new AfterWorldSaveEventArgs());
}
catch (Exception e)
{
throw new Exception("FATAL: Exception in EventSink.AfterWorldSave", e);
}
}
public abstract void Save(SaveMetrics metrics, bool permitBackgroundWrite);
