public async Task <Chunk> FetchChunk(ChunkReference chunkLocation, bool autoCreate) { // 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.AsFilepath()); Chunk loadedChunk; if (File.Exists(chunkFilePath)) // If the chunk exists on disk, load it { loadedChunk = await Chunk.FromFile(this, chunkFilePath); } else { // Ooooh! It's a _new_, never-before-seen one! Create a brand new chunk :D // ....but only if we've been told it's ok to create new chunks. if (!autoCreate) { return(null); } loadedChunk = new Chunk(this, ChunkSize, chunkLocation); } loadedChunk.OnChunkUpdate += HandleChunkUpdate; loadedChunkspace.Add(chunkLocation, loadedChunk); return(loadedChunk); }
public async Task SaveChunk(ChunkReference chunkLocation) { // It doesn't exist, so we can't save it :P if (!loadedChunkspace.ContainsKey(chunkLocation)) { return; } Chunk chunk = loadedChunkspace[chunkLocation]; string chunkFilePath = Path.Combine(StorageDirectory, chunkLocation.AsFilepath()); // If it's empty, then there's no point in saving it if (chunk.IsEmpty) { // Delete the existing chunk file, if it if (File.Exists(chunkFilePath)) { File.Delete(chunkFilePath); } return; } using (Stream chunkDestination = File.Open(chunkFilePath, FileMode.OpenOrCreate)) await chunk.SaveTo(chunkDestination); }
/// <summary> /// Works out whether a chunk currently exists. /// </summary> /// <param name="chunkLocation">The chunk location to check.</param> /// <returns>Whether the chunk at specified location exists or not.</returns> public bool HasChunk(ChunkReference chunkLocation) { if (loadedChunkspace.ContainsKey(chunkLocation)) { return(true); } string chunkFilePath = Path.Combine(StorageDirectory, chunkLocation.AsFilepath()); if (File.Exists(chunkFilePath)) { return(true); } return(false); }
public override bool Equals(object obj) { ChunkReference otherChunkReference = obj as ChunkReference; if (otherChunkReference == null) { return(false); } if (X == otherChunkReference.X && Y == otherChunkReference.Y && Plane == otherChunkReference.Plane) { return(true); } return(false); }
private async Task LoadPrimaryChunks() { List <ChunkReference> primaryChunkRefs = new List <ChunkReference>(); ChunkReference currentRef = new ChunkReference(this, -PrimaryChunkAreaSize, -PrimaryChunkAreaSize); while (currentRef.Y < PrimaryChunkAreaSize) { primaryChunkRefs.Add(currentRef.Clone() as ChunkReference); currentRef.X++; if (currentRef.X > PrimaryChunkAreaSize) { currentRef.X = -PrimaryChunkAreaSize; currentRef.Y++; } } await FetchChunks(primaryChunkRefs, false); }
public Chunk(Plane inPlane, int inSize, ChunkReference inLocation) { plane = inPlane; Size = inSize; Location = inLocation; }
public async Task <bool> RemoveLineSegment(ChunkReference containingChunk, string targetLineUniqueId) { Chunk chunk = await FetchChunk(containingChunk); return(chunk.Remove(targetLineUniqueId)); }
public async Task <Chunk> FetchChunk(ChunkReference chunkLocation) { return(await FetchChunk(chunkLocation, true)); }
/// <summary> /// Splits this line into a list of lines that don't cross chunk boundaries. /// </summary> /// <returns>A list of lines, that, when stitched together, will produce this line.</returns> public List <DrawnLine> SplitOnChunks() { List <DrawnLine> results = new List <DrawnLine>(); // Don't bother splitting the line up if it all falls in the same chunk if (!SpansMultipleChunks) { results.Add(this); return(results); } DrawnLine nextLine = new DrawnLine(LineId); ChunkReference currentChunk = null; foreach (LocationReference point in Points) { if (currentChunk != null && !point.ContainingChunk.Equals(currentChunk)) { // We're heading into a new chunk! Split the line up here. // TODO: Add connecting lines to each DrawnLine instance to prevent gaps nextLine.Colour = Colour; nextLine.Width = Width; if (nextLine.Points.Count > 0) { results.Add(nextLine); } nextLine = new DrawnLine(LineId); } nextLine.Points.Add(point); if (!point.ContainingChunk.Equals(currentChunk)) { currentChunk = point.ContainingChunk; } } if (nextLine.Points.Count > 0) { nextLine.Colour = Colour; nextLine.Width = Width; results.Add(nextLine); } // Set the ContinuesIn and ContinuesFrom properties // so that clients can find the next / previous chunk line fragmentss for (int i = 0; i < results.Count - 1; i++) { // Set the ContinuesFrom reference, but not on the first fragment in the list if (i > 0) { results[i].ContinuesFrom = results[i - 1].ContainingChunk; results[i].ContinuesFromId = results[i - 1].UniqueId; } // Set the ContinuesIn reference, but not on the last fragment in the list if (i < results.Count - 1) { results[i].ContinuesIn = results[i + 1].ContainingChunk; results[i].ContinuesWithId = results[i + 1].UniqueId; } } return(results); }