mirror of
https://github.com/sbrl/Nibriboard.git
synced 2018-01-10 21:33:49 +00:00
93 lines
2.4 KiB
C#
93 lines
2.4 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Threading.Tasks;
|
|
using System.IO;
|
|
|
|
namespace Nibriboard.RippleSpace
|
|
{
|
|
/// <summary>
|
|
/// Represents an infinite plane.
|
|
/// </summary>
|
|
public class Plane
|
|
{
|
|
/// <summary>
|
|
/// The name of this plane.
|
|
/// </summary>
|
|
public readonly string Name;
|
|
|
|
/// <summary>
|
|
/// The size of the chunks on this plane.
|
|
/// </summary>
|
|
public readonly int ChunkSize;
|
|
|
|
/// <summary>
|
|
/// The path to the directory that the plane's information will be stored in.
|
|
/// </summary>
|
|
public readonly string StorageDirectory;
|
|
|
|
/// <summary>
|
|
/// The number of milliseconds that should pass since a chunk's last
|
|
/// access in order for it to be considered inactive.
|
|
/// </summary>
|
|
public int InactiveMillisecs = 60 * 1000;
|
|
|
|
/// <summary>
|
|
/// The number of chunks in a square around (0, 0) that should always be
|
|
/// loaded.
|
|
/// </summary>
|
|
public int PrimaryChunkAreaSize = 10;
|
|
|
|
/// <summary>
|
|
/// The chunkspace that holds the currently loaded and active chunks.
|
|
/// </summary>
|
|
protected Dictionary<ChunkReference, Chunk> loadedChunkspace = new Dictionary<ChunkReference, Chunk>();
|
|
|
|
public Plane(string inName, int inChunkSize)
|
|
{
|
|
Name = inName;
|
|
ChunkSize = inChunkSize;
|
|
|
|
StorageDirectory = $"./Planes/{Name}";
|
|
}
|
|
|
|
public async Task<Chunk> FetchChunk(ChunkReference chunkLocation)
|
|
{
|
|
// If the chunk is in the loaded chunk-space, then return it immediately
|
|
if(loadedChunkspace.ContainsKey(chunkLocation))
|
|
{
|
|
return loadedChunkspace[chunkLocation];
|
|
}
|
|
|
|
// Uh-oh! The chunk isn't loaded at moment. Load it quick & then
|
|
// return it fast.
|
|
string chunkFilePath = Path.Combine(StorageDirectory, chunkLocation.AsFilename());
|
|
Chunk loadedChunk = await Chunk.FromFile(this, chunkFilePath);
|
|
loadedChunkspace.Add(chunkLocation, loadedChunk);
|
|
|
|
return loadedChunk;
|
|
}
|
|
|
|
public async Task AddLine(DrawnLine newLine)
|
|
{
|
|
List<DrawnLine> chunkedLine;
|
|
// Split the line up into chunked pieces if neccessary
|
|
if(newLine.SpansMultipleChunks)
|
|
chunkedLine = newLine.SplitOnChunks(ChunkSize);
|
|
else
|
|
chunkedLine = new List<DrawnLine>() { newLine };
|
|
|
|
// Add each segment to the appropriate chunk
|
|
foreach(DrawnLine newLineSegment in chunkedLine)
|
|
{
|
|
Chunk containingChunk = await FetchChunk(newLineSegment.ContainingChunk);
|
|
containingChunk.Add(newLineSegment);
|
|
}
|
|
}
|
|
|
|
public async Task PerformMaintenance()
|
|
{
|
|
// TODO: Perform maintenance here
|
|
}
|
|
}
|
|
}
|