1 files changed, 97 insertions, 0 deletions

diff --git a/src/ChunkStay.h b/src/ChunkStay.h
new file mode 100644
index 000000000..80b084aee
--- /dev/null
+++ b/src/ChunkStay.h
@@ -0,0 +1,97 @@
+
+// ChunkStay.h
+
+/* Declares the cChunkStay class representing a base for classes that want to wait for certain chunks to load,
+then do some action on them. While the object is enabled, the chunks contained within are locked and will
+not unload
+*/
+
+
+
+
+
+#pragma once
+
+
+
+
+
+// fwd
+class cChunkMap;
+
+
+
+
+
+/** Makes chunks stay loaded until this object is cleared or destroyed
+Works by setting internal flags in the cChunk that it should not be unloaded.
+To optimize for speed, cChunkStay has an Enabled flag, it will "stay" the chunks only when enabled
+and it will refuse chunk-list manipulations when enabled.
+The object itself is not made thread-safe, it's supposed to be used from a single thread only.
+This class is abstract, the descendants are expected to provide the OnChunkAvailable() and
+the OnAllChunksAvailable() callback implementations. Note that those are called from the contexts of
+different threads' - the caller, the Loader or the Generator thread.
+*/
+class cChunkStay
+{
+public:
+	cChunkStay(void);
+	~cChunkStay();
+	
+	void Clear(void);
+	
+	/** Adds a chunk to be locked from unloading.
+	To be used only while the ChunkStay object is not enabled. */
+	void Add(int a_ChunkX, int a_ChunkZ);
+	
+	/** Releases the chunk so that it's no longer locked from unloading.
+	To be used only while the ChunkStay object is not enabled. */
+	void Remove(int a_ChunkX, int a_ChunkZ);
+	
+	/** Enables the ChunkStay on the specified chunkmap, causing it to load and generate chunks.
+	All the contained chunks are queued for loading / generating. */
+	void Enable (cChunkMap & a_ChunkMap);
+	
+	/** Disables the ChunkStay, the chunks are released and the ChunkStay
+	object can be edited with Add() and Remove() again*/
+	virtual void Disable(void);
+	
+	/** Returns all the chunks that should be kept */
+	const cChunkCoordsVector & GetChunks(void) const { return m_Chunks; }
+	
+	/** Called when a specific chunk become available. */
+	virtual void OnChunkAvailable(int a_ChunkX, int a_ChunkZ) = 0;
+	
+	/** Caled once all of the contained chunks are available.
+	If returns true, the ChunkStay is automatically disabled by the ChunkMap; if it returns false, the ChunkStay is kept. */
+	virtual bool OnAllChunksAvailable(void) = 0;
+	
+	/** Called by the ChunkMap when the ChunkStay is disabled. The object may choose to delete itself. */
+	virtual void OnDisabled(void) = 0;
+	
+protected:
+
+	friend class cChunkMap;
+
+
+	/** The chunkmap where the object is enabled.
+	Valid only after call to Enable() and before Disable(). */
+	cChunkMap * m_ChunkMap;
+	
+	/** The list of chunks to lock from unloading. */
+	cChunkCoordsVector m_Chunks;
+	
+	/** The chunks that still need loading */
+	cChunkCoordsVector m_OutstandingChunks;
+	
+	
+	/** Called by cChunkMap when a chunk is available, checks m_NumLoaded and triggers the appropriate callbacks.
+	May be called for chunks outside this ChunkStay.
+	Returns true if the ChunkStay is to be automatically disabled by the ChunkMap; returns false to keep the ChunkStay. */
+	bool ChunkAvailable(int a_ChunkX, int a_ChunkZ);
+} ;
+
+
+
+
+