From 585571d78ca9ff5e384cae8d006a391df0f17ff7 Mon Sep 17 00:00:00 2001 From: Mattes D Date: Mon, 13 Feb 2017 16:50:35 +0100 Subject: PieceGenerator: Added rotation-aware vertical connectors. --- tests/PieceRotation/Bindings.h | 15 ++ tests/PieceRotation/CMakeLists.txt | 102 ++++++++++ tests/PieceRotation/LuaState_Declaration.inc | 4 + tests/PieceRotation/LuaState_Typedefs.inc | 19 ++ tests/PieceRotation/PieceRotationTest.cpp | 170 ++++++++++++++++ tests/PieceRotation/Stubs.cpp | 290 +++++++++++++++++++++++++++ 6 files changed, 600 insertions(+) create mode 100644 tests/PieceRotation/Bindings.h create mode 100644 tests/PieceRotation/CMakeLists.txt create mode 100644 tests/PieceRotation/LuaState_Declaration.inc create mode 100644 tests/PieceRotation/LuaState_Typedefs.inc create mode 100644 tests/PieceRotation/PieceRotationTest.cpp create mode 100644 tests/PieceRotation/Stubs.cpp (limited to 'tests/PieceRotation') diff --git a/tests/PieceRotation/Bindings.h b/tests/PieceRotation/Bindings.h new file mode 100644 index 000000000..490830ac3 --- /dev/null +++ b/tests/PieceRotation/Bindings.h @@ -0,0 +1,15 @@ + +// Bindings.h + +// Dummy include file needed for LuaState to compile successfully + + + + +struct lua_State; + +int tolua_AllToLua_open(lua_State * a_LuaState); + + + + diff --git a/tests/PieceRotation/CMakeLists.txt b/tests/PieceRotation/CMakeLists.txt new file mode 100644 index 000000000..53b4f273f --- /dev/null +++ b/tests/PieceRotation/CMakeLists.txt @@ -0,0 +1,102 @@ +enable_testing() + +include_directories(${CMAKE_SOURCE_DIR}/src/) +include_directories(SYSTEM ${CMAKE_SOURCE_DIR}/lib/) +include_directories(${CMAKE_CURRENT_SOURCE_DIR}) + +add_definitions(-DTEST_GLOBALS=1) + +set (SHARED_SRCS + ${CMAKE_SOURCE_DIR}/src/BiomeDef.cpp + ${CMAKE_SOURCE_DIR}/src/BlockArea.cpp + ${CMAKE_SOURCE_DIR}/src/Cuboid.cpp + ${CMAKE_SOURCE_DIR}/src/ChunkData.cpp + ${CMAKE_SOURCE_DIR}/src/StringCompression.cpp + ${CMAKE_SOURCE_DIR}/src/StringUtils.cpp + + ${CMAKE_SOURCE_DIR}/src/Bindings/LuaState.cpp + + ${CMAKE_SOURCE_DIR}/src/Generating/ChunkDesc.cpp + ${CMAKE_SOURCE_DIR}/src/Generating/PieceGenerator.cpp + ${CMAKE_SOURCE_DIR}/src/Generating/Prefab.cpp + ${CMAKE_SOURCE_DIR}/src/Generating/PrefabPiecePool.cpp + ${CMAKE_SOURCE_DIR}/src/Generating/VerticalLimit.cpp + ${CMAKE_SOURCE_DIR}/src/Generating/VerticalStrategy.cpp + + ${CMAKE_SOURCE_DIR}/src/Noise/Noise.cpp + + ${CMAKE_SOURCE_DIR}/src/OSSupport/CriticalSection.cpp + ${CMAKE_SOURCE_DIR}/src/OSSupport/Event.cpp + ${CMAKE_SOURCE_DIR}/src/OSSupport/File.cpp + ${CMAKE_SOURCE_DIR}/src/OSSupport/GZipFile.cpp + ${CMAKE_SOURCE_DIR}/src/OSSupport/StackTrace.cpp + + ${CMAKE_SOURCE_DIR}/src/WorldStorage/FastNBT.cpp + ${CMAKE_SOURCE_DIR}/src/WorldStorage/SchematicFileSerializer.cpp +) + +set (SHARED_HDRS + ${CMAKE_SOURCE_DIR}/src/BiomeDef.h + ${CMAKE_SOURCE_DIR}/src/BlockArea.h + ${CMAKE_SOURCE_DIR}/src/Cuboid.h + ${CMAKE_SOURCE_DIR}/src/ChunkData.h + ${CMAKE_SOURCE_DIR}/src/Globals.h + ${CMAKE_SOURCE_DIR}/src/StringCompression.h + ${CMAKE_SOURCE_DIR}/src/StringUtils.h + + ${CMAKE_SOURCE_DIR}/src/Bindings/LuaState.h + + ${CMAKE_SOURCE_DIR}/src/Generating/ChunkDesc.h + ${CMAKE_SOURCE_DIR}/src/Generating/PieceGenerator.h + ${CMAKE_SOURCE_DIR}/src/Generating/Prefab.h + ${CMAKE_SOURCE_DIR}/src/Generating/PrefabPiecePool.h + ${CMAKE_SOURCE_DIR}/src/Generating/VerticalLimit.h + ${CMAKE_SOURCE_DIR}/src/Generating/VerticalStrategy.h + + ${CMAKE_SOURCE_DIR}/src/Noise/Noise.h + + ${CMAKE_SOURCE_DIR}/src/OSSupport/CriticalSection.h + ${CMAKE_SOURCE_DIR}/src/OSSupport/Event.h + ${CMAKE_SOURCE_DIR}/src/OSSupport/File.h + ${CMAKE_SOURCE_DIR}/src/OSSupport/GZipFile.h + ${CMAKE_SOURCE_DIR}/src/OSSupport/StackTrace.h + + ${CMAKE_SOURCE_DIR}/src/WorldStorage/FastNBT.h + ${CMAKE_SOURCE_DIR}/src/WorldStorage/SchematicFileSerializer.h +) + +set (SRCS + PieceRotationTest.cpp + Stubs.cpp + LuaState_Typedefs.inc + LuaState_Declaration.inc + Bindings.h +) + + +if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") + add_flags_cxx("-Wno-error=global-constructors") + add_flags_cxx("-Wno-error=switch-enum") +endif() + + +if (MSVC) + # Add the MSVC-specific LeakFinder sources: + list (APPEND SHARED_SRCS ${CMAKE_SOURCE_DIR}/src/LeakFinder.cpp ${CMAKE_SOURCE_DIR}/src/StackWalker.cpp) + list (APPEND SHARED_HDRS ${CMAKE_SOURCE_DIR}/src/LeakFinder.h ${CMAKE_SOURCE_DIR}/src/StackWalker.h) +endif() + +source_group("Shared" FILES ${SHARED_SRCS} ${SHARED_HDRS}) +source_group("Sources" FILES ${SRCS}) +add_executable(PieceRotation ${SRCS} ${SHARED_SRCS} ${SHARED_HDRS}) +target_link_libraries(PieceRotation tolualib zlib) +add_test(NAME PieceRotation-test WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND PieceRotation) + + + + +# Put the projects into solution folders (MSVC): +set_target_properties( + PieceRotation + PROPERTIES FOLDER Tests +) diff --git a/tests/PieceRotation/LuaState_Declaration.inc b/tests/PieceRotation/LuaState_Declaration.inc new file mode 100644 index 000000000..4019b26c6 --- /dev/null +++ b/tests/PieceRotation/LuaState_Declaration.inc @@ -0,0 +1,4 @@ + +// LuaState_Declaration.inc + +// Dummy include file needed for LuaState to compile successfully diff --git a/tests/PieceRotation/LuaState_Typedefs.inc b/tests/PieceRotation/LuaState_Typedefs.inc new file mode 100644 index 000000000..5eba7c6f8 --- /dev/null +++ b/tests/PieceRotation/LuaState_Typedefs.inc @@ -0,0 +1,19 @@ + +// LuaState_Typedefs.inc + +// Dummy include file needed for LuaState to compile successfully + + + + + +// Forward-declare classes that are used in the API but never called: +struct HTTPRequest; +struct HTTPTemplateRequest; +class cPluginLua; +class cBoundingBox; +template class cItemCallback; +class cEntity; + + + diff --git a/tests/PieceRotation/PieceRotationTest.cpp b/tests/PieceRotation/PieceRotationTest.cpp new file mode 100644 index 000000000..3e325b54c --- /dev/null +++ b/tests/PieceRotation/PieceRotationTest.cpp @@ -0,0 +1,170 @@ +// PieceRotation.cpp + +// Implements the tests for cPiece::cConnector::eDirection rotations + +#include "Globals.h" +#include +#include +#include "Generating/PieceGenerator.h" + + + + + +static cPiece::cConnector::eDirection g_AllDirections[] = +{ + cPiece::cConnector::dirXM, + cPiece::cConnector::dirXP, + cPiece::cConnector::dirYM, + cPiece::cConnector::dirYP, + cPiece::cConnector::dirZM, + cPiece::cConnector::dirZP, + cPiece::cConnector::dirYM_XM_ZM, + cPiece::cConnector::dirYM_XM_ZP, + cPiece::cConnector::dirYM_XP_ZM, + cPiece::cConnector::dirYM_XP_ZP, + cPiece::cConnector::dirYP_XM_ZM, + cPiece::cConnector::dirYP_XM_ZP, + cPiece::cConnector::dirYP_XP_ZM, + cPiece::cConnector::dirYP_XP_ZP, +}; + + + + + +class cTestFailure: public std::exception +{ +public: + cTestFailure(const char * a_Expression, const char * a_FileName, const int a_Line): + std::exception(), + m_Expression(a_Expression), + m_FileName(a_FileName), + m_Line(a_Line) + { + } + + const std::string m_Expression; + const std::string m_FileName; + const int m_Line; +}; + + + + + +#define EXPECT(X) if (!(X)) \ + { \ + ASSERT(X); \ + throw cTestFailure(#X, __FILE__, __LINE__); \ + } + + + + + +/** Tests that rotating a direction in one way and then the opposite way produces the original direction. */ +static void testBackAndForth() +{ + for (size_t i = 0; i < ARRAYCOUNT(g_AllDirections); ++i) + { + auto rotated = cPiece::cConnector::RotateDirectionCW(g_AllDirections[i]); + auto back = cPiece::cConnector::RotateDirectionCCW(rotated); + EXPECT(back == g_AllDirections[i]); + } + for (size_t i = 0; i < ARRAYCOUNT(g_AllDirections); ++i) + { + auto rotated = cPiece::cConnector::RotateDirectionCCW(g_AllDirections[i]); + auto back = cPiece::cConnector::RotateDirectionCW(rotated); + EXPECT(back == g_AllDirections[i]); + } +} + + + + + +/** Tests rotating the direction 360 degrees. */ +static void testFullRotation() +{ + // Rotate 90 degrees CCW four times: + for (size_t i = 0; i < ARRAYCOUNT(g_AllDirections); ++i) + { + auto d = g_AllDirections[i]; + for (int j = 0; j < 4; ++j) + { + d = cPiece::cConnector::RotateDirectionCCW(d); + } + EXPECT(d == g_AllDirections[i]); + } + + // Rotate 90 degrees CW four times: + for (size_t i = 0; i < ARRAYCOUNT(g_AllDirections); ++i) + { + auto d = g_AllDirections[i]; + for (int j = 0; j < 4; ++j) + { + d = cPiece::cConnector::RotateDirectionCW(d); + } + EXPECT(d == g_AllDirections[i]); + } + + // Rotate 180 degrees twice: + for (size_t i = 0; i < ARRAYCOUNT(g_AllDirections); ++i) + { + auto d = g_AllDirections[i]; + d = cPiece::cConnector::RotateDirection(d); + d = cPiece::cConnector::RotateDirection(d); + EXPECT(d == g_AllDirections[i]); + } +} + + + + + +/** Tests that no two values are rotated onto the same destination value. */ +template +static void testPermutation(Fn & a_Fn) +{ + std::map numDest; + for (size_t i = 0; i < ARRAYCOUNT(g_AllDirections); ++i) + { + auto d = a_Fn(g_AllDirections[i]); + EXPECT(numDest[d] == 0); + numDest[d] = 1; + } +} + + + + + +int main(void) +{ + LOG("PieceRotation test starting."); + try + { + testBackAndForth(); + testFullRotation(); + testPermutation(cPiece::cConnector::RotateDirection); + testPermutation(cPiece::cConnector::RotateDirectionCW); + testPermutation(cPiece::cConnector::RotateDirectionCCW); + } + catch (const cTestFailure & f) + { + LOGERROR("Test failed:\tExpression: %s\n\tFile: %s (%d)", f.m_Expression.c_str(), f.m_FileName.c_str(), f.m_Line); + return 1; + } + catch (const std::exception & exc) + { + LOGERROR("Exception caught: %s", exc.what()); + return 2; + } + LOG("PieceRotation test succeeded."); + return 0; +} + + + + diff --git a/tests/PieceRotation/Stubs.cpp b/tests/PieceRotation/Stubs.cpp new file mode 100644 index 000000000..0ad3eb365 --- /dev/null +++ b/tests/PieceRotation/Stubs.cpp @@ -0,0 +1,290 @@ + +// Stubs.cpp + +// Implements stubs of various Cuberite methods that are needed for linking but not for runtime +// This is required so that we don't bring in the entire Cuberite via dependencies + +#include "Globals.h" +#include "BlockInfo.h" +#include "Bindings.h" +#include "Bindings/DeprecatedBindings.h" +#include "Bindings/LuaJson.h" +#include "Bindings/ManualBindings.h" +#include "BlockEntities/BlockEntity.h" +#include "Blocks/BlockHandler.h" +#include "Generating/ChunkDesc.h" +#include "DeadlockDetect.h" + + + + + +// fwd: +struct lua_State; + + + + + +// Prototypes, needed by clang: +extern "C" int luaopen_lsqlite3(lua_State * a_LuaState); +extern "C" int luaopen_lxp(lua_State * a_LuaState); + + + + + +void cManualBindings::Bind(lua_State * a_LuaState) +{ +} + + + + + +void DeprecatedBindings::Bind(lua_State * a_LuaState) +{ +} + + + + + +void cLuaJson::Bind(cLuaState & a_LuaState) +{ +} + + + + + +int tolua_AllToLua_open(lua_State * a_LuaState) +{ + return 0; +} + + + + + +extern "C" int luaopen_lsqlite3(lua_State * a_LuaState) +{ + return 0; +} + + + + + +extern "C" int luaopen_lxp(lua_State * a_LuaState) +{ + return 0; +} + + + + + +cBlockInfo::~cBlockInfo() +{ +} + + + + + +void cBlockInfo::Initialize(cBlockInfo::cBlockInfoArray & a_BlockInfos) +{ + // The piece-loading code uses the handlers for rotations, so we need valid handlers + // Insert dummy handlers: + for (size_t i = 0; i < ARRAYCOUNT(a_BlockInfos); i++) + { + a_BlockInfos[i].m_Handler = new cBlockHandler(static_cast(i)); + } +} + + + + + +cBlockHandler::cBlockHandler(BLOCKTYPE a_BlockType) +{ +} + + + + + +bool cBlockHandler::GetPlacementBlockTypeMeta( + cChunkInterface & a_ChunkInterface, cPlayer * a_Player, + int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace, + int a_CursorX, int a_CursorY, int a_CursorZ, + BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta +) +{ + return true; +} + + + + + +void cBlockHandler::OnUpdate(cChunkInterface & cChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_PluginInterface, cChunk & a_Chunk, int a_BlockX, int a_BlockY, int a_BlockZ) +{ +} + + + + + +void cBlockHandler::OnPlacedByPlayer(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, const sSetBlock & a_BlockChange) +{ +} + + + + + +void cBlockHandler::OnDestroyedByPlayer(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ) +{ +} + + + + + +void cBlockHandler::OnPlaced(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta) +{ +} + + + + + +void cBlockHandler::OnDestroyed(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, int a_BlockX, int a_BlockY, int a_BlockZ) +{ +} + + + + + +void cBlockHandler::NeighborChanged(cChunkInterface & a_ChunkInterface, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_WhichNeighbor) +{ +} + + + + + +void cBlockHandler::ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) +{ +} + + + + + +void cBlockHandler::DropBlock(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cBlockPluginInterface & a_BlockPluginInterface, cEntity * a_Digger, int a_BlockX, int a_BlockY, int a_BlockZ, bool a_CanDrop) +{ +} + + + + + +bool cBlockHandler::CanBeAt(cChunkInterface & a_ChunkInterface, int a_BlockX, int a_BlockY, int a_BlockZ, const cChunk & a_Chunk) +{ + return true; +} + + + + + +bool cBlockHandler::IsUseable() +{ + return false; +} + + + + + +bool cBlockHandler::IsClickedThrough(void) +{ + return false; +} + + + + + +bool cBlockHandler::DoesIgnoreBuildCollision(void) +{ + return (m_BlockType == E_BLOCK_AIR); +} + + + + + +bool cBlockHandler::DoesDropOnUnsuitable(void) +{ + return true; +} + + + + + +void cBlockHandler::Check(cChunkInterface & a_ChunkInterface, cBlockPluginInterface & a_PluginInterface, int a_RelX, int a_RelY, int a_RelZ, cChunk & a_Chunk) +{ +} + + + + + +ColourID cBlockHandler::GetMapBaseColourID(NIBBLETYPE a_Meta) +{ + return 0; +} + + + + + +bool cBlockHandler::IsInsideBlock(const Vector3d & a_Position, const BLOCKTYPE a_BlockType, const NIBBLETYPE a_BlockMeta) +{ + return true; +} + + + + + +cBlockEntity * cBlockEntity::CreateByBlockType(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_World) +{ + return nullptr; +} + + + + + +void cDeadlockDetect::TrackCriticalSection(cCriticalSection & a_CS, const AString & a_Name) +{ +} + + + + + +void cDeadlockDetect::UntrackCriticalSection(cCriticalSection & a_CS) +{ +} + + + + -- cgit v1.2.3