From 2df14a04962037b93352c2fc53349af54ab3b14d Mon Sep 17 00:00:00 2001
From: peterbell10 <peterbell10@live.co.uk>
Date: Sun, 4 Feb 2018 22:15:31 +0000
Subject: cChunk and cChunkData: Use vectors for block get and set functions
 (#4172)

* cChunkData: Change interface to use Vector3i
* cChunk: Add Vector3i overloads for bounded block get and set functions.
---
 tests/ChunkData/Coordinates.cpp | 86 ++++++++++++++++++++---------------------
 1 file changed, 43 insertions(+), 43 deletions(-)

(limited to 'tests/ChunkData/Coordinates.cpp')

diff --git a/tests/ChunkData/Coordinates.cpp b/tests/ChunkData/Coordinates.cpp
index 384af7e03..31aa1179e 100644
--- a/tests/ChunkData/Coordinates.cpp
+++ b/tests/ChunkData/Coordinates.cpp
@@ -25,98 +25,98 @@ int main(int argc, char** argv)
 		cChunkData buffer(Pool);
 
 		// Empty chunks
-		buffer.SetBlock(0, 0, 0, 0xAB);
-		testassert(buffer.GetBlock(0, 0, 0) == 0xAB);
-		buffer.SetMeta(0, 16, 0, 0xC);
-		testassert(buffer.GetMeta(0, 16, 0) == 0xC);
+		buffer.SetBlock({ 0, 0, 0 }, 0xAB);
+		testassert(buffer.GetBlock({ 0, 0, 0 }) == 0xAB);
+		buffer.SetMeta({ 0, 16, 0 }, 0xC);
+		testassert(buffer.GetMeta({ 0, 16, 0 }) == 0xC);
 
 		// loaded but not written segments
-		testassert(buffer.GetBlock(1, 0, 0) == 0x0);
-		testassert(buffer.GetMeta(1, 16, 0) == 0x0);
+		testassert(buffer.GetBlock({ 1, 0, 0 }) == 0x0);
+		testassert(buffer.GetMeta({ 1, 16, 0 }) == 0x0);
 
 		// Notloaded segments
-		testassert(buffer.GetBlock(0, 32, 0) == 0x0);
-		testassert(buffer.GetMeta(0, 48, 0) == 0x0);
+		testassert(buffer.GetBlock({ 0, 32, 0 }) == 0x0);
+		testassert(buffer.GetMeta({ 0, 48, 0 }) == 0x0);
 
 		// Out of range SetBlock
 		CheckAsserts(
-			buffer.SetBlock(-1, 0, 0, 0);
+			buffer.SetBlock({ -1, 0, 0 }, 0);
 		);
 		CheckAsserts(
-			buffer.SetBlock(0, -1, 0, 0);
+			buffer.SetBlock({ 0, -1, 0 }, 0);
 		);
 		CheckAsserts(
-			buffer.SetBlock(0, 0, -1, 0);
+			buffer.SetBlock({ 0, 0, -1 }, 0);
 		);
 		CheckAsserts(
-			buffer.SetBlock(256, 0, 0, 0);
+			buffer.SetBlock({ 256, 0, 0 }, 0);
 		);
 		CheckAsserts(
-			buffer.SetBlock(0, 256, 0, 0);
+			buffer.SetBlock({ 0, 256, 0 }, 0);
 		);
 		CheckAsserts(
-			buffer.SetBlock(0, 0, 256, 0);
+			buffer.SetBlock({ 0, 0, 256 }, 0);
 		);
 		// Out of range SetMeta
 		CheckAsserts(
-			buffer.SetMeta(-1, 0, 0, 0);
+			buffer.SetMeta({ -1, 0, 0 }, 0);
 		);
 		CheckAsserts(
-			buffer.SetMeta(0, -1, 0, 0);
+			buffer.SetMeta({ 0, -1, 0 }, 0);
 		);
 		CheckAsserts(
-			buffer.SetMeta(0, 0, -1, 0);
+			buffer.SetMeta({ 0, 0, -1 }, 0);
 		);
 		CheckAsserts(
-			buffer.SetMeta(256, 0, 0, 0);
+			buffer.SetMeta({ 256, 0, 0 }, 0);
 		);
 		CheckAsserts(
-			buffer.SetMeta(0, 256, 0, 0);
+			buffer.SetMeta({ 0, 256, 0 }, 0);
 		);
 		CheckAsserts(
-			buffer.SetMeta(0, 0, 256, 0);
+			buffer.SetMeta({ 0, 0, 256 }, 0);
 		);
 
 		// Reading out of range blocks should return air
-		testassert(buffer.GetBlock(-1, 0, 0) == 0);
-		testassert(buffer.GetBlock(0, -1, 0) == 0);
-		testassert(buffer.GetBlock(0, 0, -1) == 0);
-		testassert(buffer.GetBlock(256, 0, 0) == 0);
-		testassert(buffer.GetBlock(0, 256, 0) == 0);
-		testassert(buffer.GetBlock(0, 0, 256) == 0);
+		testassert(buffer.GetBlock({ -1, 0, 0 }) == 0);
+		testassert(buffer.GetBlock({ 0, -1, 0 }) == 0);
+		testassert(buffer.GetBlock({ 0, 0, -1 }) == 0);
+		testassert(buffer.GetBlock({ 256, 0, 0 }) == 0);
+		testassert(buffer.GetBlock({ 0, 256, 0 }) == 0);
+		testassert(buffer.GetBlock({ 0, 0, 256 }) == 0);
 
 		// Reading out of range metas should return 0
-		testassert(buffer.GetMeta(-1, 0, 0) == 0);
-		testassert(buffer.GetMeta(0, -1, 0) == 0);
-		testassert(buffer.GetMeta(0, 0, -1) == 0);
-		testassert(buffer.GetMeta(256, 0, 0) == 0);
-		testassert(buffer.GetMeta(0, 256, 0) == 0);
-		testassert(buffer.GetMeta(0, 0, 256) == 0);
+		testassert(buffer.GetMeta({ -1, 0, 0 }) == 0);
+		testassert(buffer.GetMeta({ 0, -1, 0 }) == 0);
+		testassert(buffer.GetMeta({ 0, 0, -1 }) == 0);
+		testassert(buffer.GetMeta({ 256, 0, 0 }) == 0);
+		testassert(buffer.GetMeta({ 0, 256, 0 }) == 0);
+		testassert(buffer.GetMeta({ 0, 0, 256 }) == 0);
 	}
 
 	{
 		cChunkData buffer(Pool);
 
 		// Zero's
-		buffer.SetBlock(0, 0, 0, 0x0);
-		buffer.SetBlock(0, 0, 1, 0xab);
-		testassert(buffer.GetBlock(0, 0, 0) == 0x0);
-		testassert(buffer.GetBlock(0, 0, 1) == 0xab);
-
-		buffer.SetMeta(0, 16, 0, 0x0);
-		buffer.SetMeta(0, 16, 1, 0xc);
-		testassert(buffer.GetMeta(0, 16, 0) == 0x0);
-		testassert(buffer.GetMeta(0, 16, 1) == 0xc);
+		buffer.SetBlock({ 0, 0, 0 }, 0x0);
+		buffer.SetBlock({ 0, 0, 1 }, 0xab);
+		testassert(buffer.GetBlock({ 0, 0, 0 }) == 0x0);
+		testassert(buffer.GetBlock({ 0, 0, 1 }) == 0xab);
+
+		buffer.SetMeta({ 0, 16, 0 }, 0x0);
+		buffer.SetMeta({ 0, 16, 1 }, 0xc);
+		testassert(buffer.GetMeta({ 0, 16, 0 }) == 0x0);
+		testassert(buffer.GetMeta({ 0, 16, 1 }) == 0xc);
 	}
 
 
 	{
 		// Operator =
 		cChunkData buffer(Pool);
-		buffer.SetBlock(0, 0, 0, 0x42);
+		buffer.SetBlock({ 0, 0, 0 }, 0x42);
 		cChunkData copy(Pool);
 		copy = std::move(buffer);
-		testassert(copy.GetBlock(0, 0, 0) == 0x42);
+		testassert(copy.GetBlock({ 0, 0, 0 }) == 0x42);
 	}
 
 	return 0;
-- 
cgit v1.2.3