feat: Block & Chunk API v2 & World region file

.github/workflows/tests_on_pr.yaml

@@ -0,0 +1,19 @@
+name: Tests On Pull Request
+
+on:
+  pull_request:
+    branches: ["master"]
+
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+      with:
+       submodules: true
+    - name: Make prepare_tests.sh exec
+      run: chmod +x ./prepare_tests.sh
+    - name: Prepare test env
+      run: ./prepare_tests.sh
+    - name: Run tests
+      run: ./testing

.gitignore

@@ -14,4 +14,6 @@ extension_api.json
 build
 
 testing.*
-testing
+testing
+
+world/

includes/cavernfall/network/buff.hpp

@@ -1,16 +1,11 @@
 #pragma once
 
+#include <utils/num.hpp>
 #include <utils/typetraits.hpp>
 
 #include <stdint.h>
 #include <stdlib.h>
 
-#include <string>
-
-#define STATE_BIG_ENDIAN 0
-#define STATE_LITTLE_ENDIAN 1
-
-#define DEFAULT_ENDIAN_STATE STATE_LITTLE_ENDIAN
 
 #define BUFFER_EXPANSION_REALLOC_RATE 2.5
 
@@ -27,7 +22,7 @@ class NetworkBuff {
 	 * @param size the amount of bytes
 	 */
 	constexpr bool can_read(size_t size) {
-		return this->readPosition + size < this->sz;
+		return this->readPosition + size <= this->sz;
 	}
 
 	/**
@@ -36,7 +31,7 @@ class NetworkBuff {
 	 * @param size the amount of bytes
 	 */
 	constexpr bool can_write(size_t size) {
-		return this->writePosition + size < this->sz;
+		return this->writePosition + size <= this->sz;
 	}
 
 	/**
@@ -78,7 +73,7 @@ class NetworkBuff {
 	~NetworkBuff();
 
 	constexpr uint8_t read_byte() {
-		if(!this->can_read(1)) return false;
+		if(!this->can_read(1)) return 0;
 		return this->buff[this->readPosition++];
 	}
 

includes/cavernfall/world/block.hpp

@@ -1,14 +1,38 @@
 #pragma once
 
 #include <stdint.h>
+#include <utils/file.hpp>
+
+#include <functional>
 
 namespace cavernfall::world {
 
-typedef uint64_t chunk_block_data_t;
-typedef uint32_t block_id_t;
-typedef uint32_t block_data_t;
+typedef uint8_t block_id_t;
+
+/**
+ * @brief The base container for all block data.
+ * @details Manages the block data reading and writing from files 
+ */
+class BlockDataContainerBase {
+public:	
+	/**
+	 * @brief Reads / Loads the block data from the given file handle.
+	 * @param handle the file handle
+	 */
+	virtual void read(cavernfall::fs::file_handle& handle) {}
+
+	/**
+	 * @brief Writes / Saves the block data to the given file handle.
+	 * @param handle the file handle
+	 */
+	virtual void write(cavernfall::fs::file_handle& handle) {}
+};
 
 class BlockType {
+private:
+	std::function<BlockDataContainerBase*()> data_constructor;
+	bool has_data_constructor;
+
 public:
 	int id;
 	bool tickable;
@@ -19,12 +43,21 @@ class BlockType {
 		this->id = 0;
 		this->tickable = false;
 		this->textureID = 0;
+		this->has_data_constructor = false;
+	}
+
+	BlockType(bool tickable, std::function<BlockDataContainerBase*()> constructor) {
+		this->id = 0;
+		this->tickable = tickable;
+		this->data_constructor = constructor;
+		this->has_data_constructor = true;
 	}
 
 	BlockType(bool tickable, int textureID) {
 		this->tickable = tickable;
 		this->textureID = textureID;
 		this->id = -1;
+		this->has_data_constructor = false;
 	}
 
 	/**
@@ -36,6 +69,11 @@ class BlockType {
 	*/
 	virtual void tick(long x, long y, long z);
 
+	/**
+	 * @brief Creates a BlockDataContainerBase base corresponding to the type.
+	 */
+	BlockDataContainerBase* create_data();
+
 };
 
 //TODO: Make this static at compile time somehow
@@ -83,14 +121,6 @@ class BlockTypeRegister {
 	}
 };
 
-class ComplexBlock {
-public:
-	chunk_block_data_t block;
-
-	ComplexBlock(chunk_block_data_t block);
-
-};
-
 /**
 * @name fill_blocktype_register
 * Fills the given register with all given block types

includes/cavernfall/world/chunk.hpp

@@ -28,28 +28,17 @@ namespace cavernfall::world {
 
 #define CHUNK_MEM_FROMIND(ind) (ind / WORLD_CHUNK_SIZE), (ind % WORLD_CHUNK_SIZE)
 
-#define CHUNK_NO_BLOCK (chunk_block_data_t)(0)
-
-typedef struct chunk_saved_data_t {
-	int height;
-	int sz;
-	chunk_block_data_t* data;
-} chunk_saved_data_t;
-
-typedef struct chunk_block_t {
-	block_id_t id;
-	block_data_t data;
-	BlockType* type;
-	ComplexBlock* block;
-};
+#define CHUNK_NO_BLOCK 0
 
 /**
  * A chunk is a 32*32 region in an Cavernfall world.
  */
 class Chunk: public cavernfall::view::ViewEngine, public cavernfall::utils::chunkpos_t {
 private:
+	std::bitset<CHUNK_SIZE_TOTAL> data_presence_cache;
+
 #if !defined(CHUNK_NO_CACHED_PACKET)
-	void __update_cached_packet(size_t block_ind, chunk_block_data_t data);
+	void __update_cached_packet(size_t block_ind, block_id_t id);
 #endif
 
 	inline void __erase(size_t ind);
@@ -59,8 +48,8 @@ class Chunk: public cavernfall::view::ViewEngine, public cavernfall::utils::chun
 	void viewer_remove(cavernfall::player::Player* player) override;
 
 public:
-	uint8_t types[CHUNK_SIZE_TOTAL];
-	chunk_block_data_t data[CHUNK_SIZE_TOTAL];
+	block_id_t data[CHUNK_SIZE_TOTAL];
+	emhash7::HashMap<size_t, BlockDataContainerBase*> block_data;
 
 #if !defined(CHUNK_NO_CACHED_PACKET)
 	cavernfall::net::NetworkBuff* load_packet;
@@ -77,15 +66,74 @@ class Chunk: public cavernfall::view::ViewEngine, public cavernfall::utils::chun
 #if !defined(CHUNK_NO_CACHED_PACKET)
 		if(this->load_packet != nullptr) delete this->load_packet;
 #endif
+
+		for(auto& it : this->block_data) {
+			delete it.second;
+		}
+
 	}
 
 	void set(int x, int z, block_id_t id);
-
-	void set(int x, int z, chunk_block_data_t blockData);
 	void set(int x, int z, BlockType* type);
 
-	chunk_block_t get(int x, int z);
+	block_id_t get(int x, int z);
+
+	/**
+	 * @brief Checks if the block at the given position has data.
+	 * @details Uses the data presence cache bitset to avoid repetitive HashMap calls.
+	 * 
+	 * @param x the X coordinate of the block (within the chunk)
+	 * @param z the Z coordinate of the block (within the chunk)
+	 */
+	bool has_data(int x, int z);
+
+	/**
+	 * @brief Gets the stored chunk data of the block at the given position.
+	 * @details First uses the presence cache bitset to check for presence then uses the Hashmap to get the data.
+	 * 
+	 * @param x the X coordinate of the block (within the chunk)
+	 * @param z the Z coordinate of the block (within the chunk)
+	 * @return the chunk data if there is some or nullptr if none
+	 */
+	BlockDataContainerBase* get_data(int x, int z);
+
+	/**
+	 * @brief Sets the stored block data of the block at the given position to the given container.
+	 * @details First uses the presence cache bitset to check for presence then uses the Hashmap to set the data, also frees the older value if there is one.
+	 * 
+	 * @param x the X coordinate of the block (within the chunk)
+	 * @param z the Z coordinate of the block (within the chunk)
+	 * @param base the new container
+	 */
+	void set_data(int x, int z, BlockDataContainerBase* base);
+
+	/**
+	 * @brief Creates a BlockDataContainerBase for the block at the given position or get the current one.
+	 * @details Creates a BlockDataContainerBase by taking the constructor from the block type corresponding to the current block at the position.
+	 * 
+	 * @param x the X coordinate of the block (within the chunk)
+	 * @param z the Z coordinate of the block (within the chunk)
+	 * 
+	 * @info will do nothing if chunk data already exists for the block.
+	 * @return the created / gathered block data
+	 */
+	BlockDataContainerBase* get_or_create_data(int x, int z);
+
+	/**
+	 * @brief Removes the data for the block at the given position.
+	 * @details Erases the BlockDataContainerBase for the block at the given position and removes it from the block data having cache.
+	 * 
+	 * @param x the X coordinate of the block (within the chunk)
+	 * @param z the Z coordinate of the block (within the chunk)
+	 * 
+	 * @info will do nothing if the block data doesn't have any data
+	 */
+	void remove_data(int x, int z);
 
+	/**
+	 * @brief Get the current amount of data containers within the chunk.
+	 */
+	size_t get_active_data_containers();
 
 	/** 
 	 * @name is_chunk_in_render_distance