public void RebuildVoxelsThread()
{
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
#if CREATE_CRASH_LOGS
try
#endif
{
while (!DwarfGame.ExitGame && !ExitThreads)
{
RebuildEvent.WaitOne();
VoxelChunk chunk = null;
do
{
chunk = PopInvalidChunk();
if (chunk != null)
{
chunk.Rebuild(GameState.Game.GraphicsDevice);
NeedsMinimapUpdate = true;
}
}while (chunk != null);
}
}
#if CREATE_CRASH_LOGS
catch (Exception exception)
{
ProgramData.WriteExceptionLog(exception);
throw;
}
#endif
}
public void UpdateWaterThread()
{
EventWaitHandle[] waitHandles =
{
WaterUpdateEvent,
Program.ShutdownEvent
};
#if CREATE_CRASH_LOGS
try
#endif
{
while (!DwarfGame.ExitGame && !ExitThreads)
{
EventWaitHandle wh = Datastructures.WaitFor(waitHandles);
if (wh == Program.ShutdownEvent)
{
break;
}
if (!PauseThreads)
{
Water.UpdateWater();
}
}
}
#if CREATE_CRASH_LOGS
catch (Exception exception)
{
ProgramData.WriteExceptionLog(exception);
}
#endif
}
public void GenerateThread()
{
EventWaitHandle[] waitHandles =
{
NeedsGenerationEvent,
Program.ShutdownEvent
};
#if CREATE_CRASH_LOGS
try
#endif
{
while (!ExitThreads)
{
EventWaitHandle wh = Datastructures.WaitFor(waitHandles);
//GeneratorLock.WaitOne();
if (!PauseThreads && ToGenerate != null && ToGenerate.Count > 0)
{
Point3 box = ToGenerate[0];
if (!ChunkData.ChunkMap.ContainsKey(box))
{
Vector3 worldPos = new Vector3(box.X * ChunkData.ChunkSizeX, box.Y * ChunkData.ChunkSizeY, box.Z * ChunkData.ChunkSizeZ);
VoxelChunk chunk = ChunkGen.GenerateChunk(worldPos, (int)ChunkData.ChunkSizeX, (int)ChunkData.ChunkSizeY, (int)ChunkData.ChunkSizeZ, Components, Content, Graphics);
Drawer3D.DrawBox(chunk.GetBoundingBox(), Color.Red, 0.1f);
chunk.ShouldRebuild = true;
chunk.ShouldRecalculateLighting = true;
GeneratedChunks.Enqueue(chunk);
}
ToGenerate.Remove(box);
}
//GeneratorLock.ReleaseMutex();
if (wh == Program.ShutdownEvent)
{
break;
}
}
}
#if CREATE_CRASH_LOGS
catch (Exception exception)
{
ProgramData.WriteExceptionLog(exception);
}
#endif
}
public void GenerateThread()
{
EventWaitHandle[] waitHandles =
{
NeedsGenerationEvent,
Program.ShutdownEvent
};
#if CREATE_CRASH_LOGS
try
#endif
{
while (!ExitThreads)
{
EventWaitHandle wh = Datastructures.WaitFor(waitHandles);
//GeneratorLock.WaitOne();
if (!PauseThreads && ToGenerate != null && ToGenerate.Count > 0)
{
System.Threading.Tasks.Parallel.ForEach(ToGenerate, box =>
{
//if (!ChunkData.CheckBounds(box))
//{
Vector3 worldPos = new Vector3(
box.X * VoxelConstants.ChunkSizeX,
box.Y * VoxelConstants.ChunkSizeY,
box.Z * VoxelConstants.ChunkSizeZ);
VoxelChunk chunk = ChunkGen.GenerateChunk(worldPos, World);
//Drawer3D.DrawBox(chunk.GetBoundingBox(), Color.Red, 0.1f, false);
//}
});
ToGenerate.Clear();
}
//GeneratorLock.ReleaseMutex();
if (wh == Program.ShutdownEvent)
{
break;
}
}
}
#if CREATE_CRASH_LOGS
catch (Exception exception)
{
ProgramData.WriteExceptionLog(exception);
}
#endif
}
public void RebuildVoxelsThread()
{
Console.Out.WriteLine("Starting chunk regeneration thread.");
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
#if !DEBUG
try
#endif
{
while (!DwarfGame.ExitGame && !ExitThreads)
{
try
{
RebuildEvent.WaitOne();
}
catch (ThreadAbortException exception)
{
continue;
}
VoxelChunk chunk = null;
do
{
chunk = PopInvalidChunk();
if (chunk != null)
{
chunk.Rebuild(GameState.Game.GraphicsDevice);
NeedsMinimapUpdate = true;
}
}while (chunk != null);
}
}
#if !DEBUG
catch (Exception exception)
{
Console.Out.WriteLine("Chunk regeneration thread exited due to an exception.");
ProgramData.WriteExceptionLog(exception);
throw;
}
#endif
Console.Out.WriteLine(String.Format("Chunk regeneration thread exited cleanly Exit Game: {0} Exit Thread: {1}.", DwarfGame.ExitGame, ExitThreads));
}
/// <summary>
/// The main entry point for the application.
/// </summary>
private static void Main(string[] args)
{
#if CREATE_CRASH_LOGS
try
#endif
{
using (DwarfGame game = new DwarfGame())
{
game.Run();
}
Program.SignalShutdown();
}
#if CREATE_CRASH_LOGS
catch (Exception exception)
{
ProgramData.WriteExceptionLog(exception);
}
#endif
}
private void LoadThreaded()
{
DwarfGame.ExitGame = false;
// Ensure we're using the invariant culture.
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
LoadStatus = LoadingStatus.Loading;
SetLoadingMessage("Initializing ...");
while (GraphicsDevice == null)
{
Thread.Sleep(100);
}
Thread.Sleep(1000);
#if !DEBUG
try
{
#endif
if (Overworld.InstanceSettings.LoadType == LoadType.CreateNew)
{
CreateNewWorld();
}
else
{
LoadFromFile();
}
#if !DEBUG
}
catch (Exception exception)
{
Program.CaptureException(exception);
LoadingException = exception;
LoadStatus = LoadingStatus.Failure;
ProgramData.WriteExceptionLog(exception);
}
#endif
}
public void UpdateWaterThread()
{
EventWaitHandle[] waitHandles =
{
WaterUpdateEvent,
Program.ShutdownEvent
};
GamePerformance.Instance.RegisterThreadLoopTracker("UpdateWater", GamePerformance.ThreadIdentifier.UpdateWater);
#if CREATE_CRASH_LOGS
try
#endif
{
while (!DwarfGame.ExitGame && !ExitThreads)
{
EventWaitHandle wh = Datastructures.WaitFor(waitHandles);
GamePerformance.Instance.PreThreadLoop(GamePerformance.ThreadIdentifier.UpdateWater);
GamePerformance.Instance.EnterZone("UpdateWater");
if (wh == Program.ShutdownEvent)
{
break;
}
if (!PauseThreads)
{
Water.UpdateWater();
}
GamePerformance.Instance.PostThreadLoop(GamePerformance.ThreadIdentifier.UpdateWater);
GamePerformance.Instance.ExitZone("UpdateWater");
}
}
#if CREATE_CRASH_LOGS
catch (Exception exception)
{
ProgramData.WriteExceptionLog(exception);
}
#endif
}
public void RebuildVoxelsThread()
{
System.Threading.Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
System.Threading.Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
GamePerformance.Instance.RegisterThreadLoopTracker("RebuildVoxels", GamePerformance.ThreadIdentifier.RebuildVoxels);
#if CREATE_CRASH_LOGS
try
#endif
{
while (!DwarfGame.ExitGame && !ExitThreads)
{
GamePerformance.Instance.PreThreadLoop(GamePerformance.ThreadIdentifier.RebuildVoxels);
GamePerformance.Instance.EnterZone("RebuildVoxels");
var chunk = PopInvalidChunk();
if (chunk != null)
{
chunk.Rebuild(Graphics);
}
else
{
System.Threading.Thread.Yield();
}
GamePerformance.Instance.PostThreadLoop(GamePerformance.ThreadIdentifier.RebuildVoxels);
GamePerformance.Instance.ExitZone("RebuildVoxels");
}
}
#if CREATE_CRASH_LOGS
catch (Exception exception)
{
ProgramData.WriteExceptionLog(exception);
throw;
}
#endif
}
public void RebuildVoxelsThread()
{
EventWaitHandle[] waitHandles =
{
NeedsRebuildEvent,
Program.ShutdownEvent
};
#if CREATE_CRASH_LOGS
try
#endif
{
while (!DwarfGame.ExitGame && !ExitThreads)
{
EventWaitHandle wh = Datastructures.WaitFor(waitHandles);
if (wh == Program.ShutdownEvent)
{
break;
}
{
if (PauseThreads)
{
continue;
}
Dictionary <Point3, VoxelChunk> toRebuild = new Dictionary <Point3, VoxelChunk>();
bool calculateRamps = GameSettings.Default.CalculateRamps;
lock (RebuildList)
{
while (RebuildList.Count > 0)
{
VoxelChunk chunk = null;
if (!RebuildList.TryDequeue(out chunk))
{
continue;
}
if (chunk == null)
{
continue;
}
toRebuild[chunk.ID] = chunk;
if (PauseThreads)
{
break;
}
}
}
if (calculateRamps)
{
foreach (VoxelChunk chunk in toRebuild.Select(chunkPair => chunkPair.Value))
{
chunk.UpdateRamps();
}
}
foreach (
VoxelChunk chunk in
toRebuild.Select(chunkPair => chunkPair.Value)
.Where(chunk => chunk.ShouldRecalculateLighting))
{
chunk.CalculateGlobalLight();
}
foreach (VoxelChunk chunk in toRebuild.Select(chunkPair => chunkPair.Value))
{
if (chunk.RebuildPending && chunk.ShouldRebuild)
{
if (chunk.ShouldRecalculateLighting)
{
chunk.CalculateVertexLighting();
}
chunk.Rebuild(Graphics);
chunk.ShouldRebuild = false;
chunk.RebuildPending = false;
chunk.ShouldRecalculateLighting = false;
}
else
{
chunk.RebuildPending = false;
}
}
}
}
}
#if CREATE_CRASH_LOGS
catch (Exception exception)
{
ProgramData.WriteExceptionLog(exception);
throw;
}
#endif
}
public void RebuildLiquidsThread()
{
EventWaitHandle[] waitHandles =
{
NeedsLiquidEvent,
Program.ShutdownEvent
};
#if CREATE_CRASH_LOGS
try
#endif
{
bool shouldExit = false;
while (!shouldExit && !DwarfGame.ExitGame && !ExitThreads)
{
EventWaitHandle wh = Datastructures.WaitFor(waitHandles);
if (wh == Program.ShutdownEvent)
{
break;
}
while (!PauseThreads && RebuildLiquidsList.Count > 0)
{
VoxelChunk chunk = null;
//LiquidLock.WaitOne();
if (!RebuildLiquidsList.TryDequeue(out chunk))
{
//LiquidLock.ReleaseMutex();
break;
}
//LiquidLock.ReleaseMutex();
if (chunk == null)
{
continue;
}
try
{
chunk.RebuildLiquids(Graphics);
chunk.RebuildLiquidPending = false;
chunk.ShouldRebuildWater = false;
}
catch (Exception e)
{
Console.Error.WriteLine(e.Message);
shouldExit = true;
break;
}
}
}
}
#if CREATE_CRASH_LOGS
catch (Exception exception)
{
ProgramData.WriteExceptionLog(exception);
}
#endif
}
private void LoadThreaded()
{
DwarfGame.ExitGame = false;
// Ensure we're using the invariant culture.
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
LoadStatus = LoadingStatus.Loading;
SetLoadingMessage("Initializing ...");
while (GraphicsDevice == null)
{
Thread.Sleep(100);
}
Thread.Sleep(1000);
#if !DEBUG
try
{
#endif
bool fileExists = !string.IsNullOrEmpty(ExistingFile);
SetLoadingMessage("Creating Sky...");
Sky = new SkyRenderer();
#region Reading game file
if (fileExists)
{
SetLoadingMessage("Loading " + ExistingFile);
gameFile = SaveGame.CreateFromDirectory(ExistingFile);
if (gameFile == null)
{
throw new InvalidOperationException("Game File does not exist.");
}
// Todo: REMOVE THIS WHEN THE NEW SAVE SYSTEM IS COMPLETE.
if (gameFile.Metadata.Version != Program.Version && !Program.CompatibleVersions.Contains(gameFile.Metadata.Version))
{
throw new InvalidOperationException(String.Format("Game file is from version {0}. Compatible versions are {1}.", gameFile.Metadata.Version,
TextGenerator.GetListString(Program.CompatibleVersions)));
}
Sky.TimeOfDay = gameFile.Metadata.TimeOfDay;
Time = gameFile.Metadata.Time;
WorldOrigin = gameFile.Metadata.WorldOrigin;
WorldScale = gameFile.Metadata.WorldScale;
WorldSize = gameFile.Metadata.NumChunks;
GameID = gameFile.Metadata.GameID;
if (gameFile.Metadata.OverworldFile != null && gameFile.Metadata.OverworldFile != "flat")
{
SetLoadingMessage("Loading world " + gameFile.Metadata.OverworldFile);
Overworld.Name = gameFile.Metadata.OverworldFile;
DirectoryInfo worldDirectory =
Directory.CreateDirectory(DwarfGame.GetWorldDirectory() +
Path.DirectorySeparatorChar + Overworld.Name);
var overWorldFile = new NewOverworldFile(worldDirectory.FullName);
Overworld.Map = overWorldFile.Data.Data;
Overworld.Name = overWorldFile.Data.Name;
}
else
{
SetLoadingMessage("Generating flat world..");
Overworld.CreateUniformLand(GraphicsDevice);
}
}
#endregion
#region Initialize static data
{
Vector3 origin = new Vector3(0, 0, 0);
Vector3 extents = new Vector3(1500, 1500, 1500);
OctTree = new OctTreeNode <Body>(origin - extents, origin + extents);
PrimitiveLibrary.Initialize(GraphicsDevice, Content);
InstanceRenderer = new InstanceRenderer(GraphicsDevice, Content);
Color[] white = new Color[1];
white[0] = Color.White;
pixel = new Texture2D(GraphicsDevice, 1, 1);
pixel.SetData(white);
Tilesheet = AssetManager.GetContentTexture(ContentPaths.Terrain.terrain_tiles);
AspectRatio = GraphicsDevice.Viewport.AspectRatio;
DefaultShader = new Shader(Content.Load <Effect>(ContentPaths.Shaders.TexturedShaders), true);
DefaultShader.ScreenWidth = GraphicsDevice.Viewport.Width;
DefaultShader.ScreenHeight = GraphicsDevice.Viewport.Height;
CraftLibrary.InitializeDefaultLibrary();
PotionLibrary.Initialize();
VoxelLibrary.InitializeDefaultLibrary(GraphicsDevice);
GrassLibrary.InitializeDefaultLibrary();
DecalLibrary.InitializeDefaultLibrary();
bloom = new BloomComponent(Game)
{
Settings = BloomSettings.PresetSettings[5]
};
bloom.Initialize();
SoundManager.Content = Content;
if (PlanService != null)
{
PlanService.Restart();
}
JobLibrary.Initialize();
MonsterSpawner = new MonsterSpawner(this);
EntityFactory.Initialize(this);
}
#endregion
SetLoadingMessage("Creating Planner ...");
PlanService = new PlanService();
SetLoadingMessage("Creating Shadows...");
Shadows = new ShadowRenderer(GraphicsDevice, 1024, 1024);
SetLoadingMessage("Creating Liquids ...");
#region liquids
WaterRenderer = new WaterRenderer(GraphicsDevice);
#endregion
SetLoadingMessage("Generating Initial Terrain Chunks ...");
if (!fileExists)
{
GameID = MathFunctions.Random.Next(0, 1024);
}
ChunkGenerator = new ChunkGenerator(VoxelLibrary, Seed, 0.02f)
{
SeaLevel = SeaLevel
};
#region Load Components
if (fileExists)
{
ChunkManager = new ChunkManager(Content, this,
ChunkGenerator, WorldSize.X, WorldSize.Y, WorldSize.Z);
Splasher = new Splasher(ChunkManager);
ChunkRenderer = new ChunkRenderer(ChunkManager.ChunkData);
SetLoadingMessage("Loading Terrain...");
gameFile.ReadChunks(ExistingFile);
ChunkManager.ChunkData.LoadFromFile(ChunkManager, gameFile, SetLoadingMessage);
SetLoadingMessage("Loading Entities...");
gameFile.LoadPlayData(ExistingFile, this);
Camera = gameFile.PlayData.Camera;
DesignationDrawer = gameFile.PlayData.Designations;
Vector3 origin = new Vector3(WorldOrigin.X, 0, WorldOrigin.Y);
Vector3 extents = new Vector3(1500, 1500, 1500);
if (gameFile.PlayData.Stats != null)
{
Stats = gameFile.PlayData.Stats;
}
if (gameFile.PlayData.Resources != null)
{
foreach (var resource in gameFile.PlayData.Resources)
{
if (!ResourceLibrary.Resources.ContainsKey(resource.Key))
{
ResourceLibrary.Add(resource.Value);
}
}
}
ComponentManager = new ComponentManager(gameFile.PlayData.Components, this);
foreach (var component in gameFile.PlayData.Components.SaveableComponents)
{
if (!ComponentManager.HasComponent(component.GlobalID) &&
ComponentManager.HasComponent(component.Parent.GlobalID))
{
// Logically impossible.
throw new InvalidOperationException("Component exists in save data but not in manager.");
}
}
ConversationMemory = gameFile.PlayData.ConversationMemory;
Factions = gameFile.PlayData.Factions;
ComponentManager.World = this;
Sky.TimeOfDay = gameFile.Metadata.TimeOfDay;
Time = gameFile.Metadata.Time;
WorldOrigin = gameFile.Metadata.WorldOrigin;
WorldScale = gameFile.Metadata.WorldScale;
// Restore native factions from deserialized data.
Natives = new List <Faction>();
foreach (Faction faction in Factions.Factions.Values)
{
if (faction.Race.IsNative && faction.Race.IsIntelligent && !faction.IsRaceFaction)
{
Natives.Add(faction);
}
}
Diplomacy = gameFile.PlayData.Diplomacy;
GoalManager = new Goals.GoalManager();
GoalManager.Initialize(new List <Goals.Goal>());// gameFile.PlayData.Goals);
TutorialManager = new Tutorial.TutorialManager();
TutorialManager.SetFromSaveData(gameFile.PlayData.TutorialSaveData);
}
else
{
Time = new WorldTime();
Camera = new OrbitCamera(this,
new Vector3(VoxelConstants.ChunkSizeX,
VoxelConstants.ChunkSizeY - 1.0f,
VoxelConstants.ChunkSizeZ),
new Vector3(VoxelConstants.ChunkSizeY, VoxelConstants.ChunkSizeY - 1.0f,
VoxelConstants.ChunkSizeZ) +
Vector3.Up * 10.0f + Vector3.Backward * 10,
MathHelper.PiOver4, AspectRatio, 0.1f,
GameSettings.Default.VertexCullDistance);
ChunkManager = new ChunkManager(Content, this,
ChunkGenerator, WorldSize.X, WorldSize.Y, WorldSize.Z);
Splasher = new Splasher(ChunkManager);
ChunkRenderer = new ChunkRenderer(ChunkManager.ChunkData);
Camera.Position = new Vector3(0, 10, 0) + new Vector3(WorldSize.X * VoxelConstants.ChunkSizeX, 0, WorldSize.Z * VoxelConstants.ChunkSizeZ) * 0.5f;
Camera.Target = new Vector3(0, 10, 1) + new Vector3(WorldSize.X * VoxelConstants.ChunkSizeX, 0, WorldSize.Z * VoxelConstants.ChunkSizeZ) * 0.5f;
ComponentManager = new ComponentManager(this);
ComponentManager.SetRootComponent(new Body(ComponentManager, "root", Matrix.Identity, Vector3.Zero, Vector3.Zero));
if (Natives == null) // Todo: Always true??
{
FactionLibrary library = new FactionLibrary();
library.Initialize(this, CompanyMakerState.CompanyInformation);
Natives = new List <Faction>();
for (int i = 0; i < 10; i++)
{
Natives.Add(library.GenerateFaction(this, i, 10));
}
}
#region Prepare Factions
foreach (Faction faction in Natives)
{
faction.World = this;
if (faction.RoomBuilder == null)
{
faction.RoomBuilder = new RoomBuilder(faction, this);
}
}
Factions = new FactionLibrary();
if (Natives != null && Natives.Count > 0)
{
Factions.AddFactions(this, Natives);
}
Factions.Initialize(this, CompanyMakerState.CompanyInformation);
Point playerOrigin = new Point((int)(WorldOrigin.X), (int)(WorldOrigin.Y));
Factions.Factions["Player"].Center = playerOrigin;
Factions.Factions["The Motherland"].Center = new Point(playerOrigin.X + 50, playerOrigin.Y + 50);
#endregion
Diplomacy = new Diplomacy(this);
Diplomacy.Initialize(Time.CurrentDate);
// Initialize goal manager here.
GoalManager = new Goals.GoalManager();
GoalManager.Initialize(new List <Goals.Goal>());
TutorialManager = new Tutorial.TutorialManager();
TutorialManager.TutorialEnabled = !GameSettings.Default.TutorialDisabledGlobally;
Tutorial("new game start");
foreach (var item in CraftLibrary.EnumerateCraftables())
{
if (!String.IsNullOrEmpty(item.Tutorial))
{
TutorialManager.AddTutorial(item.Name, item.Tutorial, item.Icon);
}
}
}
Camera.World = this;
//Drawer3D.Camera = Camera;
#endregion
SetLoadingMessage("Creating Particles ...");
ParticleManager = new ParticleManager(ComponentManager);
SetLoadingMessage("Creating GameMaster ...");
Master = new GameMaster(Factions.Factions["Player"], Game, ComponentManager, ChunkManager,
Camera, GraphicsDevice);
// If there's no file, we have to initialize the first chunk coordinate
if (gameFile == null)
{
ChunkManager.GenerateInitialChunks(SpawnRect,
new GlobalChunkCoordinate(0, 0, 0),
SetLoadingMessage);
}
if (gameFile != null)
{
if (gameFile.PlayData.Tasks != null)
{
Master.NewArrivals = gameFile.PlayData.NewArrivals ?? new List <GameMaster.ApplicantArrival>();
Master.TaskManager = gameFile.PlayData.Tasks;
Master.TaskManager.Faction = Master.Faction;
}
if (gameFile.PlayData.InitialEmbark != null)
{
InitialEmbark = gameFile.PlayData.InitialEmbark;
}
ChunkManager.World.Master.SetMaxViewingLevel(gameFile.Metadata.Slice > 0
? gameFile.Metadata.Slice
: ChunkManager.World.Master.MaxViewingLevel);
}
if (Master.Faction.Economy.Company.Information == null)
{
Master.Faction.Economy.Company.Information = new CompanyInformation();
}
CreateInitialEmbarkment();
foreach (var chunk in ChunkManager.ChunkData.ChunkMap)
{
chunk.CalculateInitialSunlight();
}
if (RevealSurface)
{
VoxelHelpers.InitialReveal(ChunkManager, ChunkManager.ChunkData, new VoxelHandle(
ChunkManager.ChunkData.GetChunkEnumerator().FirstOrDefault(), new LocalVoxelCoordinate(0, VoxelConstants.ChunkSizeY - 1, 0)));
}
foreach (var chunk in ChunkManager.ChunkData.ChunkMap)
{
ChunkManager.InvalidateChunk(chunk);
}
SetLoadingMessage("Creating Geometry...");
ChunkManager.GenerateAllGeometry();
ChunkManager.StartThreads();
SetLoadingMessage("Presimulating ...");
ShowingWorld = false;
OnLoadedEvent();
Thread.Sleep(1000);
ShowingWorld = true;
SetLoadingMessage("Complete.");
// GameFile is no longer needed.
gameFile = null;
LoadStatus = LoadingStatus.Success;
#if !DEBUG
}
catch (Exception exception)
{
Game.CaptureException(exception);
LoadingException = exception;
LoadStatus = LoadingStatus.Failure;
ProgramData.WriteExceptionLog(exception);
}
#endif
}
private void MainLoop()
{
GamePerformance.Instance.RegisterThreadLoopTracker(Identifier.ToString(), Identifier);
#if CREATE_CRASH_LOGS
try
#endif
{
while (!DwarfGame.ExitGame && !Manager.ExitThreads)
{
if (Program.ShutdownEvent.WaitOne(1))
{
break;
}
if (!Manager.PauseThreads)
{
var timeNow = DateTime.Now;
var delta = timeNow - LastRan;
if (delta.TotalSeconds >= Frequency)
{
LastRan = timeNow;
GamePerformance.Instance.PreThreadLoop(Identifier);
GamePerformance.Instance.EnterZone(Identifier.ToString());
Worker(1.0f);
var endTime = DateTime.Now;
RecentRuns.AddLast(new Run
{
StartTime = timeNow,
Duration = endTime - timeNow
});
while (RecentRuns.Count > MaxRecordsTracked)
{
RecentRuns.RemoveFirst();
}
var sumTime = RecentRuns.Sum(r => r.Duration.TotalSeconds);
var runTimeSpan = (endTime - RecentRuns.First.Value.StartTime).TotalSeconds;
var timeUsed = sumTime / runTimeSpan;
if (timeUsed > TimeBudget)
{
Frequency = Math.Min(Frequency * (1.0f + FrequencyStep), MaxFrequency);
}
else if (timeUsed < TimeBudget)
{
Frequency = Math.Max(Frequency * (1.0f - FrequencyStep), MinFrequency);
}
GamePerformance.Instance.TrackValueType("Water Update Frequency", Frequency);
GamePerformance.Instance.PostThreadLoop(Identifier);
GamePerformance.Instance.ExitZone(Identifier.ToString());
}
else
{
var sleepTime = (Frequency - delta.TotalSeconds) * 1000;
Thread.Sleep((int)sleepTime);
}
}
}
}
#if CREATE_CRASH_LOGS
catch (Exception exception)
{
ProgramData.WriteExceptionLog(exception);
}
#endif
}
public void RebuildVoxelsThread()
{
Console.Out.WriteLine("Starting chunk regeneration thread.");
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
var liveChunks = new List <VoxelChunk>();
#if !DEBUG
try
#endif
{
while (!DwarfGame.ExitGame && !ExitThreads)
{
try
{
RebuildEvent.WaitOne();
}
catch (ThreadAbortException exception)
{
continue;
}
VoxelChunk chunk = null;
do
{
chunk = PopInvalidChunk();
if (chunk != null)
{
if (!chunk.Visible)
{
continue; // Don't bother rebuilding chunks that won't be rendered.
}
chunk.Rebuild(GameState.Game.GraphicsDevice);
liveChunks.Add(chunk);
if (liveChunks.Count() > GameSettings.Current.MaxLiveChunks)
{
liveChunks.Sort((a, b) => a.RenderCycleWhenLastVisible - b.RenderCycleWhenLastVisible);
while (liveChunks.Count() > GameSettings.Current.MaxLiveChunks)
{
if (liveChunks[0].Visible)
{
break;
}
liveChunks[0].DiscardPrimitive();
liveChunks.RemoveAt(0);
}
}
NeedsMinimapUpdate = true; // Soon to be redundant.
}
}while (chunk != null);
PerformanceMonitor.SetMetric("VISIBLE CHUNKS", liveChunks.Count);
}
}
#if !DEBUG
catch (Exception exception)
{
Console.Out.WriteLine("Chunk regeneration thread encountered an exception.");
ProgramData.WriteExceptionLog(exception);
//throw;
}
#endif
Console.Out.WriteLine(String.Format("Chunk regeneration thread exited cleanly Exit Game: {0} Exit Thread: {1}.", DwarfGame.ExitGame, ExitThreads));
}
private void MainLoop()
{
#if !DEBUG
try
#endif
{
while (!DwarfGame.ExitGame && !Manager.ExitThreads)
{
if (Program.ShutdownEvent.WaitOne(1))
{
break;
}
if (!Manager.PauseThreads)
{
var timeNow = DateTime.Now;
var delta = timeNow - LastRan;
if (delta.TotalSeconds >= Frequency)
{
LastRan = timeNow;
Worker(1.0f);
var endTime = DateTime.Now;
RecentRuns.AddLast(new Run
{
StartTime = timeNow,
Duration = endTime - timeNow
});
while (RecentRuns.Count > MaxRecordsTracked)
{
RecentRuns.RemoveFirst();
}
var sumTime = RecentRuns.Sum(r => r.Duration.TotalSeconds);
var runTimeSpan = (endTime - RecentRuns.First.Value.StartTime).TotalSeconds;
var timeUsed = sumTime / runTimeSpan;
if (timeUsed > TimeBudget)
{
Frequency = Math.Min(Frequency * (1.0f + FrequencyStep), MaxFrequency);
}
else if (timeUsed < TimeBudget)
{
Frequency = Math.Max(Frequency * (1.0f - FrequencyStep), MinFrequency);
}
}
else
{
var sleepTime = (Frequency - delta.TotalSeconds) * 1000;
Thread.Sleep((int)sleepTime);
}
}
}
}
#if !DEBUG
catch (Exception exception)
{
ProgramData.WriteExceptionLog(exception);
throw;
}
#endif
}
