initial commit

internal/chunk/sub_chunk.go

@@ -0,0 +1,66 @@
+package chunk
+
+// SubChunk is a cube of blocks located in a chunk. It has a size of 16x16x16 blocks and forms part of a stack
+// that forms a Chunk.
+type SubChunk struct {
+	air        uint32
+	storages   []*PalettedStorage
+	blockLight []uint8
+	skyLight   []uint8
+}
+
+// NewSubChunk creates a new sub chunk. All sub chunks should be created through this function
+func NewSubChunk(air uint32) *SubChunk {
+	return &SubChunk{air: air}
+}
+
+// Empty checks if the SubChunk is considered empty. This is the case if the SubChunk has 0 block storages or if it has
+// a single one that is completely filled with air.
+func (sub *SubChunk) Empty() bool {
+	return len(sub.storages) == 0 || (len(sub.storages) == 1 && len(sub.storages[0].palette.values) == 1 && sub.storages[0].palette.values[0] == sub.air)
+}
+
+// Layer returns a certain block storage/layer from a sub chunk. If no storage at the layer exists, the layer
+// is created, as well as all layers between the current highest layer and the new highest layer.
+func (sub *SubChunk) Layer(layer uint8) *PalettedStorage {
+	for uint8(len(sub.storages)) <= layer {
+		// Keep appending to storages until the requested layer is achieved. Makes working with new layers
+		// much easier.
+		sub.storages = append(sub.storages, emptyStorage(sub.air))
+	}
+	return sub.storages[layer]
+}
+
+// Layers returns all layers in the sub chunk. This method may also return an empty slice.
+func (sub *SubChunk) Layers() []*PalettedStorage {
+	return sub.storages
+}
+
+// Block returns the runtime ID of the block located at the given X, Y and Z. X, Y and Z must be in a
+// range of 0-15.
+func (sub *SubChunk) Block(x, y, z byte, layer uint8) uint32 {
+	if uint8(len(sub.storages)) <= layer {
+		return sub.air
+	}
+	return sub.storages[layer].At(x, y, z)
+}
+
+// SetBlock sets the given block runtime ID at the given X, Y and Z. X, Y and Z must be in a range of 0-15.
+func (sub *SubChunk) SetBlock(x, y, z byte, layer uint8, block uint32) {
+	sub.Layer(layer).Set(x, y, z, block)
+}
+
+// Compact cleans the garbage from all block storages that sub chunk contains, so that they may be
+// cleanly written to a database.
+func (sub *SubChunk) compact() {
+	newStorages := make([]*PalettedStorage, 0, len(sub.storages))
+	for _, storage := range sub.storages {
+		storage.compact()
+		if len(storage.palette.values) == 1 && storage.palette.values[0] == sub.air {
+			// If the palette has only air in it, it means the storage is empty, so we can ignore it.
+			continue
+		}
+		newStorages = append(newStorages, storage)
+	}
+	sub.storages = newStorages
+}