pax_global_header00006660000000000000000000000064135501557770014531gustar00rootroot0000000000000052 comment=2c16966d678f76ba7622ca8ff6995576c5b055cc minetestmapper-20191011/000077500000000000000000000000001355015577700150265ustar00rootroot00000000000000minetestmapper-20191011/.gitignore000066400000000000000000000001761355015577700170220ustar00rootroot00000000000000colors.txt minetestmapper minetestmapper.exe CMakeCache.txt CMakeFiles/ CPack* Makefile cmake_install.cmake cmake_config.h *~ minetestmapper-20191011/.travis.yml000066400000000000000000000003471355015577700171430ustar00rootroot00000000000000language: cpp compiler: - gcc - clang dist: bionic before_install: sudo apt-get install -y cmake libgd-dev libsqlite3-dev libleveldb-dev script: ./util/travis/script.sh notifications: email: false matrix: fast_finish: true minetestmapper-20191011/AUTHORS000066400000000000000000000001521355015577700160740ustar00rootroot00000000000000Miroslav Bendík ShadowNinja sfan5 minetestmapper-20191011/BlockDecoder.cpp000066400000000000000000000064741355015577700200650ustar00rootroot00000000000000#include #include #include #include #include "BlockDecoder.h" #include "ZlibDecompressor.h" static inline uint16_t readU16(const unsigned char *data) { return data[0] << 8 | data[1]; } static int readBlockContent(const unsigned char *mapData, u8 version, unsigned int datapos) { if (version >= 24) { size_t index = datapos << 1; return (mapData[index] << 8) | mapData[index + 1]; } else if (version >= 20) { if (mapData[datapos] <= 0x80) return mapData[datapos]; else return (int(mapData[datapos]) << 4) | (int(mapData[datapos + 0x2000]) >> 4); } std::ostringstream oss; oss << "Unsupported map version " << version; throw std::runtime_error(oss.str()); } BlockDecoder::BlockDecoder() { reset(); } void BlockDecoder::reset() { m_blockAirId = -1; m_blockIgnoreId = -1; m_nameMap.clear(); m_version = 0; m_mapData = ustring(); } void BlockDecoder::decode(const ustring &datastr) { const unsigned char *data = datastr.c_str(); size_t length = datastr.length(); // TODO: bounds checks uint8_t version = data[0]; //uint8_t flags = data[1]; m_version = version; size_t dataOffset = 0; if (version >= 27) dataOffset = 6; else if (version >= 22) dataOffset = 4; else dataOffset = 2; ZlibDecompressor decompressor(data, length); decompressor.setSeekPos(dataOffset); m_mapData = decompressor.decompress(); decompressor.decompress(); // unused metadata dataOffset = decompressor.seekPos(); // Skip unused data if (version <= 21) dataOffset += 2; if (version == 23) dataOffset += 1; if (version == 24) { uint8_t ver = data[dataOffset++]; if (ver == 1) { uint16_t num = readU16(data + dataOffset); dataOffset += 2; dataOffset += 10 * num; } } // Skip unused static objects dataOffset++; // Skip static object version int staticObjectCount = readU16(data + dataOffset); dataOffset += 2; for (int i = 0; i < staticObjectCount; ++i) { dataOffset += 13; uint16_t dataSize = readU16(data + dataOffset); dataOffset += dataSize + 2; } dataOffset += 4; // Skip timestamp // Read mapping if (version >= 22) { dataOffset++; // mapping version uint16_t numMappings = readU16(data + dataOffset); dataOffset += 2; for (int i = 0; i < numMappings; ++i) { uint16_t nodeId = readU16(data + dataOffset); dataOffset += 2; uint16_t nameLen = readU16(data + dataOffset); dataOffset += 2; std::string name(reinterpret_cast(data) + dataOffset, nameLen); if (name == "air") m_blockAirId = nodeId; else if (name == "ignore") m_blockIgnoreId = nodeId; else m_nameMap[nodeId] = name; dataOffset += nameLen; } } // Node timers if (version >= 25) { dataOffset++; uint16_t numTimers = readU16(data + dataOffset); dataOffset += 2; dataOffset += numTimers * 10; } } bool BlockDecoder::isEmpty() const { // only contains ignore and air nodes? return m_nameMap.empty(); } std::string BlockDecoder::getNode(u8 x, u8 y, u8 z) const { unsigned int position = x + (y << 4) + (z << 8); int content = readBlockContent(m_mapData.c_str(), m_version, position); if (content == m_blockAirId || content == m_blockIgnoreId) return ""; NameMap::const_iterator it = m_nameMap.find(content); if (it == m_nameMap.end()) { std::cerr << "Skipping node with invalid ID." << std::endl; return ""; } return it->second; } minetestmapper-20191011/CMakeLists.txt000066400000000000000000000154161355015577700175750ustar00rootroot00000000000000project(minetestmapper CXX) cmake_minimum_required(VERSION 2.6) cmake_policy(SET CMP0003 NEW) set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake) set(VERSION_MAJOR 1) set(VERSION_MINOR 0) set(VERSION_STRING "${VERSION_MAJOR}.${VERSION_MINOR}") # Stuff & Paths if(NOT CMAKE_BUILD_TYPE) set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build." FORCE) endif() set(CMAKE_CXX_FLAGS_RELEASE "-O3 -Wall -DNDEBUG") set(CMAKE_CXX_FLAGS_DEBUG "-O0 -g2 -Wall") if(WIN32) set(SHAREDIR ".") set(BINDIR ".") set(DOCDIR ".") else() set(SHAREDIR "${CMAKE_INSTALL_PREFIX}/share/minetest") # reuse Minetest share dir set(BINDIR "${CMAKE_INSTALL_PREFIX}/bin") set(DOCDIR "${CMAKE_INSTALL_PREFIX}/share/doc/${PROJECT_NAME}") set(MANDIR "${CMAKE_INSTALL_PREFIX}/share/man") endif() set(CUSTOM_SHAREDIR "" CACHE STRING "Directory to install data files into") if(NOT CUSTOM_SHAREDIR STREQUAL "") set(SHAREDIR "${CUSTOM_SHAREDIR}") message(STATUS "Using SHAREDIR=${SHAREDIR}") endif() set(CUSTOM_BINDIR "" CACHE STRING "Directory to install binaries into") if(NOT CUSTOM_BINDIR STREQUAL "") set(BINDIR "${CUSTOM_BINDIR}") message(STATUS "Using BINDIR=${BINDIR}") endif() set(CUSTOM_DOCDIR "" CACHE STRING "Directory to install documentation into") if(NOT CUSTOM_DOCDIR STREQUAL "") set(DOCDIR "${CUSTOM_DOCDIR}") message(STATUS "Using DOCDIR=${DOCDIR}") endif() # Libraries: gd find_library(LIBGD_LIBRARY gd) find_path(LIBGD_INCLUDE_DIR gd.h) message (STATUS "libgd library: ${LIBGD_LIBRARY}") message (STATUS "libgd headers: ${LIBGD_INCLUDE_DIR}") if(NOT LIBGD_LIBRARY OR NOT LIBGD_INCLUDE_DIR) message(FATAL_ERROR "libgd not found!") endif(NOT LIBGD_LIBRARY OR NOT LIBGD_INCLUDE_DIR) # Libraries: zlib find_library(ZLIB_LIBRARY z) find_path(ZLIB_INCLUDE_DIR zlib.h) message (STATUS "zlib library: ${ZLIB_LIBRARY}") message (STATUS "zlib headers: ${ZLIB_INCLUDE_DIR}") if(NOT ZLIB_LIBRARY OR NOT ZLIB_INCLUDE_DIR) message(FATAL_ERROR "zlib not found!") endif(NOT ZLIB_LIBRARY OR NOT ZLIB_INCLUDE_DIR) find_package(PkgConfig) include(FindPackageHandleStandardArgs) # Libraries: sqlite3 find_library(SQLITE3_LIBRARY sqlite3) find_path(SQLITE3_INCLUDE_DIR zlib.h) message (STATUS "sqlite3 library: ${SQLITE3_LIBRARY}") message (STATUS "sqlite3 headers: ${SQLITE3_INCLUDE_DIR}") if(NOT SQLITE3_LIBRARY OR NOT SQLITE3_INCLUDE_DIR) message(FATAL_ERROR "sqlite3 not found!") endif(NOT SQLITE3_LIBRARY OR NOT SQLITE3_INCLUDE_DIR) # Libraries: postgresql option(ENABLE_POSTGRESQL "Enable PostgreSQL backend" TRUE) set(USE_POSTGRESQL 0) if(ENABLE_POSTGRESQL) find_program(POSTGRESQL_CONFIG_EXECUTABLE pg_config DOC "pg_config") find_library(POSTGRESQL_LIBRARY pq) if(POSTGRESQL_CONFIG_EXECUTABLE) execute_process(COMMAND ${POSTGRESQL_CONFIG_EXECUTABLE} --includedir-server OUTPUT_VARIABLE POSTGRESQL_SERVER_INCLUDE_DIRS OUTPUT_STRIP_TRAILING_WHITESPACE) execute_process(COMMAND ${POSTGRESQL_CONFIG_EXECUTABLE} OUTPUT_VARIABLE POSTGRESQL_CLIENT_INCLUDE_DIRS OUTPUT_STRIP_TRAILING_WHITESPACE) # This variable is case sensitive for the cmake PostgreSQL module set(PostgreSQL_ADDITIONAL_SEARCH_PATHS ${POSTGRESQL_SERVER_INCLUDE_DIRS} ${POSTGRESQL_CLIENT_INCLUDE_DIRS}) endif() find_package("PostgreSQL") if(POSTGRESQL_FOUND) set(USE_POSTGRESQL 1) message(STATUS "PostgreSQL backend enabled") # This variable is case sensitive, don't try to change it to POSTGRESQL_INCLUDE_DIR message(STATUS "PostgreSQL includes: ${PostgreSQL_INCLUDE_DIR}") include_directories(${PostgreSQL_INCLUDE_DIR}) set(POSTGRESQL_LIBRARY ${PostgreSQL_LIBRARIES}) else() message(STATUS "PostgreSQL not found.") set(POSTGRESQL_LIBRARY "") endif() endif(ENABLE_POSTGRESQL) # Libraries: leveldb set(USE_LEVELDB 0) OPTION(ENABLE_LEVELDB "Enable LevelDB backend") if(ENABLE_LEVELDB) find_library(LEVELDB_LIBRARY leveldb) find_path(LEVELDB_INCLUDE_DIR db.h PATH_SUFFIXES leveldb) message (STATUS "LevelDB library: ${LEVELDB_LIBRARY}") message (STATUS "LevelDB headers: ${LEVELDB_INCLUDE_DIR}") if(LEVELDB_LIBRARY AND LEVELDB_INCLUDE_DIR) set(USE_LEVELDB 1) message(STATUS "LevelDB backend enabled") include_directories(${LEVELDB_INCLUDE_DIR}) else(LEVELDB_LIBRARY AND LEVELDB_INCLUDE_DIR) set(USE_LEVELDB 0) message(STATUS "LevelDB not found!") endif(LEVELDB_LIBRARY AND LEVELDB_INCLUDE_DIR) endif(ENABLE_LEVELDB) # Libraries: redis set(USE_REDIS 0) OPTION(ENABLE_REDIS "Enable redis backend") if(ENABLE_REDIS) find_library(REDIS_LIBRARY hiredis) find_path(REDIS_INCLUDE_DIR hiredis.h PATH_SUFFIXES hiredis) message (STATUS "redis library: ${REDIS_LIBRARY}") message (STATUS "redis headers: ${REDIS_INCLUDE_DIR}") if(REDIS_LIBRARY AND REDIS_INCLUDE_DIR) set(USE_REDIS 1) message(STATUS "redis backend enabled") include_directories(${REDIS_INCLUDE_DIR}) else(REDIS_LIBRARY AND REDIS_INCLUDE_DIR) set(USE_REDIS 0) message(STATUS "redis not found!") endif(REDIS_LIBRARY AND REDIS_INCLUDE_DIR) endif(ENABLE_REDIS) # Compiling & Linking include_directories( "${PROJECT_BINARY_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/include" "${CMAKE_CURRENT_BINARY_DIR}" ${SQLITE3_INCLUDE_DIR} ${LIBGD_INCLUDE_DIR} ${ZLIB_INCLUDE_DIR} ) configure_file( "${PROJECT_SOURCE_DIR}/include/cmake_config.h.in" "${PROJECT_BINARY_DIR}/cmake_config.h" ) add_definitions ( -DUSE_CMAKE_CONFIG_H ) set(mapper_SRCS BlockDecoder.cpp PixelAttributes.cpp PlayerAttributes.cpp TileGenerator.cpp ZlibDecompressor.cpp Image.cpp mapper.cpp util.cpp db-sqlite3.cpp ) if(USE_POSTGRESQL) set(mapper_SRCS ${mapper_SRCS} db-postgresql.cpp) endif(USE_POSTGRESQL) if(USE_LEVELDB) set(mapper_SRCS ${mapper_SRCS} db-leveldb.cpp) endif(USE_LEVELDB) if(USE_REDIS) set(mapper_SRCS ${mapper_SRCS} db-redis.cpp) endif(USE_REDIS) add_executable(minetestmapper ${mapper_SRCS} ) target_link_libraries( minetestmapper ${SQLITE3_LIBRARY} ${POSTGRESQL_LIBRARY} ${LEVELDB_LIBRARY} ${REDIS_LIBRARY} ${LIBGD_LIBRARY} ${ZLIB_LIBRARY} ) # Installing & Packaging install(TARGETS "${PROJECT_NAME}" DESTINATION "${BINDIR}") install(FILES "AUTHORS" DESTINATION "${DOCDIR}") install(FILES "COPYING" DESTINATION "${DOCDIR}") install(FILES "README.rst" DESTINATION "${DOCDIR}") install(FILES "colors.txt" DESTINATION "${SHAREDIR}") if(UNIX) install(FILES "minetestmapper.6" DESTINATION "${MANDIR}/man6") endif() set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Overview mapper for Minetest") set(CPACK_PACKAGE_VERSION_MAJOR ${VERSION_MAJOR}) set(CPACK_PACKAGE_VERSION_MINOR ${VERSION_MINOR}) set(CPACK_PACKAGE_VENDOR "celeron55") set(CPACK_PACKAGE_CONTACT "Perttu Ahola ") if(WIN32) set(CPACK_PACKAGE_FILE_NAME "${PROJECT_NAME}-${VERSION_STRING}-win32") set(CPACK_GENERATOR ZIP) else() set(CPACK_PACKAGE_FILE_NAME "${PROJECT_NAME}-${VERSION_STRING}-linux") set(CPACK_GENERATOR TGZ) set(CPACK_SOURCE_GENERATOR TGZ) endif() include(CPack) minetestmapper-20191011/COPYING000066400000000000000000000025051355015577700160630ustar00rootroot00000000000000Copyright (c) 2013-2014, Miroslav Bendík and various contributors (see AUTHORS) All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. minetestmapper-20191011/Image.cpp000066400000000000000000000057441355015577700165660ustar00rootroot00000000000000#include #include #include #include #include #include #include #include #include "Image.h" #ifndef NDEBUG #define SIZECHECK(x, y) check_bounds((x), (y), m_width, m_height) #else #define SIZECHECK(x, y) do {} while(0) #endif // ARGB but with inverted alpha static inline int color2int(Color c) { u8 a = (255 - c.a) * gdAlphaMax / 255; return (a << 24) | (c.r << 16) | (c.g << 8) | c.b; } static inline Color int2color(int c) { Color c2; u8 a; c2.b = c & 0xff; c2.g = (c >> 8) & 0xff; c2.r = (c >> 16) & 0xff; a = (c >> 24) & 0xff; c2.a = 255 - (a*255 / gdAlphaMax); return c2; } static inline void check_bounds(int x, int y, int width, int height) { if(x < 0 || x >= width) { std::ostringstream oss; oss << "Access outside image bounds (x), 0 < " << x << " < " << width << " is false."; throw std::out_of_range(oss.str()); } if(y < 0 || y >= height) { std::ostringstream oss; oss << "Access outside image bounds (y), 0 < " << y << " < " << height << " is false."; throw std::out_of_range(oss.str()); } } Image::Image(int width, int height) : m_width(width), m_height(height), m_image(NULL) { m_image = gdImageCreateTrueColor(m_width, m_height); } Image::~Image() { gdImageDestroy(m_image); } void Image::setPixel(int x, int y, const Color &c) { SIZECHECK(x, y); m_image->tpixels[y][x] = color2int(c); } Color Image::getPixel(int x, int y) { SIZECHECK(x, y); return int2color(m_image->tpixels[y][x]); } void Image::drawLine(int x1, int y1, int x2, int y2, const Color &c) { SIZECHECK(x1, y1); SIZECHECK(x2, y2); gdImageLine(m_image, x1, y1, x2, y2, color2int(c)); } void Image::drawText(int x, int y, const std::string &s, const Color &c) { SIZECHECK(x, y); gdImageString(m_image, gdFontGetMediumBold(), x, y, (unsigned char*) s.c_str(), color2int(c)); } void Image::drawFilledRect(int x, int y, int w, int h, const Color &c) { SIZECHECK(x, y); SIZECHECK(x + w - 1, y + h - 1); gdImageFilledRectangle(m_image, x, y, x + w - 1, y + h - 1, color2int(c)); } void Image::drawCircle(int x, int y, int diameter, const Color &c) { SIZECHECK(x, y); gdImageArc(m_image, x, y, diameter, diameter, 0, 360, color2int(c)); } void Image::save(const std::string &filename) { #if (GD_MAJOR_VERSION == 2 && GD_MINOR_VERSION == 1 && GD_RELEASE_VERSION >= 1) || (GD_MAJOR_VERSION == 2 && GD_MINOR_VERSION > 1) || GD_MAJOR_VERSION > 2 const char *f = filename.c_str(); if (gdSupportsFileType(f, 1) == GD_FALSE) throw std::runtime_error("Image format not supported by gd"); if (gdImageFile(m_image, f) == GD_FALSE) throw std::runtime_error("Error saving image"); #else if (filename.compare(filename.length() - 4, 4, ".png") != 0) throw std::runtime_error("Only PNG is supported"); FILE *f = fopen(filename.c_str(), "wb"); if (!f) { std::ostringstream oss; oss << "Error opening image file: " << std::strerror(errno); throw std::runtime_error(oss.str()); } gdImagePng(m_image, f); fclose(f); #endif } minetestmapper-20191011/PixelAttributes.cpp000066400000000000000000000023561355015577700206700ustar00rootroot00000000000000/* * ===================================================================== * Version: 1.0 * Created: 25.08.2012 10:55:27 * Author: Miroslav Bendík * Company: LinuxOS.sk * ===================================================================== */ #include #include #include "PixelAttributes.h" using namespace std; PixelAttributes::PixelAttributes(): m_width(0) { for (size_t i = 0; i < LineCount; ++i) { m_pixelAttributes[i] = 0; } } PixelAttributes::~PixelAttributes() { freeAttributes(); } void PixelAttributes::setWidth(int width) { freeAttributes(); m_width = width + 1; // 1px gradient calculation for (size_t i = 0; i < LineCount; ++i) { m_pixelAttributes[i] = new PixelAttribute[m_width]; } } void PixelAttributes::scroll() { size_t lineLength = m_width * sizeof(PixelAttribute); memcpy(m_pixelAttributes[FirstLine], m_pixelAttributes[LastLine], lineLength); for (size_t i = 1; i < LineCount - 1; ++i) { memcpy(m_pixelAttributes[i], m_pixelAttributes[EmptyLine], lineLength); } } void PixelAttributes::freeAttributes() { for (size_t i = 0; i < LineCount; ++i) { if (m_pixelAttributes[i] != 0) { delete[] m_pixelAttributes[i]; m_pixelAttributes[i] = 0; } } } minetestmapper-20191011/PlayerAttributes.cpp000066400000000000000000000057451355015577700210500ustar00rootroot00000000000000#include #include #include #include #include // for usleep #include #include "config.h" #include "PlayerAttributes.h" #include "util.h" using namespace std; PlayerAttributes::PlayerAttributes(const std::string &worldDir) { std::ifstream ifs((worldDir + "world.mt").c_str()); if (!ifs.good()) throw std::runtime_error("Failed to read world.mt"); std::string backend = read_setting_default("player_backend", ifs, "files"); ifs.close(); if (backend == "files") readFiles(worldDir + "players"); else if (backend == "sqlite3") readSqlite(worldDir + "players.sqlite"); else throw std::runtime_error(((std::string) "Unknown player backend: ") + backend); } void PlayerAttributes::readFiles(const std::string &playersPath) { DIR *dir; dir = opendir (playersPath.c_str()); if (dir == NULL) return; struct dirent *ent; while ((ent = readdir (dir)) != NULL) { if (ent->d_name[0] == '.') continue; string path = playersPath + PATH_SEPARATOR + ent->d_name; ifstream in(path.c_str()); if(!in.good()) continue; string name, position; name = read_setting("name", in); in.seekg(0); position = read_setting("position", in); Player player; istringstream iss(position); char tmp; iss >> tmp; // '(' iss >> player.x; iss >> tmp; // ',' iss >> player.y; iss >> tmp; // ',' iss >> player.z; iss >> tmp; // ')' if(tmp != ')') continue; player.name = name; player.x /= 10.0; player.y /= 10.0; player.z /= 10.0; m_players.push_back(player); } closedir(dir); } /**********/ #define SQLRES(f, good) \ result = (sqlite3_##f); \ if (result != good) { \ throw std::runtime_error(sqlite3_errmsg(db));\ } #define SQLOK(f) SQLRES(f, SQLITE_OK) void PlayerAttributes::readSqlite(const std::string &db_name) { int result; sqlite3 *db; sqlite3_stmt *stmt_get_player_pos; SQLOK(open_v2(db_name.c_str(), &db, SQLITE_OPEN_READONLY | SQLITE_OPEN_PRIVATECACHE, 0)) SQLOK(prepare_v2(db, "SELECT name, posX, posY, posZ FROM player", -1, &stmt_get_player_pos, NULL)) while ((result = sqlite3_step(stmt_get_player_pos)) != SQLITE_DONE) { if (result == SQLITE_BUSY) { // Wait some time and try again usleep(10000); } else if (result != SQLITE_ROW) { throw std::runtime_error(sqlite3_errmsg(db)); } Player player; const unsigned char *name_ = sqlite3_column_text(stmt_get_player_pos, 0); player.name = std::string(reinterpret_cast(name_)); player.x = sqlite3_column_double(stmt_get_player_pos, 1); player.y = sqlite3_column_double(stmt_get_player_pos, 2); player.z = sqlite3_column_double(stmt_get_player_pos, 3); player.x /= 10.0; player.y /= 10.0; player.z /= 10.0; m_players.push_back(player); } sqlite3_finalize(stmt_get_player_pos); sqlite3_close(db); } /**********/ PlayerAttributes::Players::iterator PlayerAttributes::begin() { return m_players.begin(); } PlayerAttributes::Players::iterator PlayerAttributes::end() { return m_players.end(); } minetestmapper-20191011/README.rst000066400000000000000000000054541355015577700165250ustar00rootroot00000000000000Minetest Mapper C++ =================== .. image:: https://travis-ci.org/minetest/minetestmapper.svg?branch=master :target: https://travis-ci.org/minetest/minetestmapper A port of minetestmapper.py to C++ from https://github.com/minetest/minetest/tree/master/util. This version is both faster and provides more features than the now deprecated Python script. Requirements ------------ * libgd * sqlite3 * LevelDB (optional, set ENABLE_LEVELDB=1 in CMake to enable) * hiredis library (optional, set ENABLE_REDIS=1 in CMake to enable) * Postgres libraries (optional, set ENABLE_POSTGRES=1 in CMake to enable) e.g. on Debian: ^^^^^^^^^^^^^^^ sudo apt-get install libgd-dev libsqlite3-dev libleveldb-dev libhiredis-dev libpq-dev Windows ^^^^^^^ Minetestmapper for Windows can be downloaded here: https://github.com/minetest/minetestmapper/releases After extracting the archive, minetestmapper can be invoked from cmd.exe: :: cd C:\Users\yourname\Desktop\example\path minetestmapper.exe --help Compilation ----------- :: cmake . -DENABLE_LEVELDB=1 make -j2 Usage ----- `minetestmapper` has two mandatory paremeters, `-i` (input world path) and `-o` (output image path). :: ./minetestmapper -i ~/.minetest/worlds/my_world/ -o map.png Parameters ^^^^^^^^^^ bgcolor: Background color of image, e.g. ``--bgcolor '#ffffff'`` scalecolor: Color of scale marks and text, e.g. ``--scalecolor '#000000'`` playercolor: Color of player indicators, e.g. ``--playercolor '#ff0000'`` origincolor: Color of origin indicator, e.g. ``--origincolor '#ff0000'`` drawscale: Draw scale(s) with tick marks and numbers, ``--drawscale`` drawplayers: Draw player indicators with name, ``--drawplayers`` draworigin: Draw origin indicator, ``--draworigin`` drawalpha: Allow nodes to be drawn with transparency (e.g. water), ``--drawalpha`` extent: Don't output any imagery, just print the extent of the full map, ``--extent`` noshading: Don't draw shading on nodes, ``--noshading`` noemptyimage: Don't output anything when the image would be empty, ``--noemptyimage`` min-y: Don't draw nodes below this y value, e.g. ``--min-y -25`` max-y: Don't draw nodes above this y value, e.g. ``--max-y 75`` backend: Override auto-detected map backend; supported: *sqlite3*, *leveldb*, *redis*, *postgresql*, e.g. ``--backend leveldb`` geometry: Limit area to specific geometry (*x:z+w+h* where x and z specify the lower left corner), e.g. ``--geometry -800:-800+1600+1600`` zoom: Apply zoom to drawn nodes by enlarging them to n*n squares, e.g. ``--zoom 4`` colors: Override auto-detected path to colors.txt, e.g. ``--colors ../minetest/mycolors.txt`` scales: Draw scales on specified image edges (letters *t b l r* meaning top, bottom, left and right), e.g. ``--scales tbr`` minetestmapper-20191011/TileGenerator.cpp000066400000000000000000000423551355015577700203070ustar00rootroot00000000000000#include #include #include #include #include #include #include #include #include #include "TileGenerator.h" #include "config.h" #include "PlayerAttributes.h" #include "BlockDecoder.h" #include "util.h" #include "db-sqlite3.h" #if USE_POSTGRESQL #include "db-postgresql.h" #endif #if USE_LEVELDB #include "db-leveldb.h" #endif #if USE_REDIS #include "db-redis.h" #endif using namespace std; template static inline T mymax(T a, T b) { return (a > b) ? a : b; } template static inline T mymin(T a, T b) { return (a > b) ? b : a; } // rounds n (away from 0) to a multiple of f while preserving the sign of n static int round_multiple_nosign(int n, int f) { int abs_n, sign; abs_n = (n >= 0) ? n : -n; sign = (n >= 0) ? 1 : -1; if (abs_n % f == 0) return n; // n == abs_n * sign else return sign * (abs_n + f - (abs_n % f)); } static inline unsigned int colorSafeBounds (int channel) { return mymin(mymax(channel, 0), 255); } static Color mixColors(Color a, Color b) { Color result; double a1 = a.a / 255.0; double a2 = b.a / 255.0; result.r = (int) (a1 * a.r + a2 * (1 - a1) * b.r); result.g = (int) (a1 * a.g + a2 * (1 - a1) * b.g); result.b = (int) (a1 * a.b + a2 * (1 - a1) * b.b); result.a = (int) (255 * (a1 + a2 * (1 - a1))); return result; } TileGenerator::TileGenerator(): m_bgColor(255, 255, 255), m_scaleColor(0, 0, 0), m_originColor(255, 0, 0), m_playerColor(255, 0, 0), m_drawOrigin(false), m_drawPlayers(false), m_drawScale(false), m_drawAlpha(false), m_shading(true), m_dontWriteEmpty(false), m_backend(""), m_xBorder(0), m_yBorder(0), m_db(NULL), m_image(NULL), m_xMin(INT_MAX), m_xMax(INT_MIN), m_zMin(INT_MAX), m_zMax(INT_MIN), m_yMin(-30000), m_yMax(30000), m_geomX(-2048), m_geomY(-2048), m_geomX2(2048), m_geomY2(2048), m_zoom(1), m_scales(SCALE_LEFT | SCALE_TOP) { } TileGenerator::~TileGenerator() { closeDatabase(); } void TileGenerator::setBgColor(const std::string &bgColor) { m_bgColor = parseColor(bgColor); } void TileGenerator::setScaleColor(const std::string &scaleColor) { m_scaleColor = parseColor(scaleColor); } void TileGenerator::setOriginColor(const std::string &originColor) { m_originColor = parseColor(originColor); } void TileGenerator::setPlayerColor(const std::string &playerColor) { m_playerColor = parseColor(playerColor); } void TileGenerator::setZoom(int zoom) { if (zoom < 1) throw std::runtime_error("Zoom level needs to be a number: 1 or higher"); m_zoom = zoom; } void TileGenerator::setScales(uint flags) { m_scales = flags; } Color TileGenerator::parseColor(const std::string &color) { Color parsed; if (color.length() != 7) throw std::runtime_error("Color needs to be 7 characters long"); if (color[0] != '#') throw std::runtime_error("Color needs to begin with #"); unsigned long col = strtoul(color.c_str() + 1, NULL, 16); parsed.b = col & 0xff; parsed.g = (col >> 8) & 0xff; parsed.r = (col >> 16) & 0xff; parsed.a = 255; return parsed; } void TileGenerator::setDrawOrigin(bool drawOrigin) { m_drawOrigin = drawOrigin; } void TileGenerator::setDrawPlayers(bool drawPlayers) { m_drawPlayers = drawPlayers; } void TileGenerator::setDrawScale(bool drawScale) { m_drawScale = drawScale; } void TileGenerator::setDrawAlpha(bool drawAlpha) { m_drawAlpha = drawAlpha; } void TileGenerator::setShading(bool shading) { m_shading = shading; } void TileGenerator::setBackend(std::string backend) { m_backend = backend; } void TileGenerator::setGeometry(int x, int y, int w, int h) { m_geomX = round_multiple_nosign(x, 16) / 16; m_geomY = round_multiple_nosign(y, 16) / 16; m_geomX2 = round_multiple_nosign(x + w, 16) / 16; m_geomY2 = round_multiple_nosign(y + h, 16) / 16; } void TileGenerator::setMinY(int y) { m_yMin = y; } void TileGenerator::setMaxY(int y) { m_yMax = y; } void TileGenerator::parseColorsFile(const std::string &fileName) { ifstream in; in.open(fileName.c_str(), ifstream::in); if (!in.is_open()) throw std::runtime_error("Specified colors file could not be found"); parseColorsStream(in); } void TileGenerator::printGeometry(const std::string &input) { string input_path = input; if (input_path[input.length() - 1] != PATH_SEPARATOR) { input_path += PATH_SEPARATOR; } openDb(input_path); loadBlocks(); std::cout << "Map extent: " << m_xMin*16 << ":" << m_zMin*16 << "+" << (m_xMax - m_xMin+1)*16 << "+" << (m_zMax - m_zMin+1)*16 << std::endl; closeDatabase(); } void TileGenerator::setDontWriteEmpty(bool f) { m_dontWriteEmpty = f; } void TileGenerator::generate(const std::string &input, const std::string &output) { string input_path = input; if (input_path[input.length() - 1] != PATH_SEPARATOR) { input_path += PATH_SEPARATOR; } openDb(input_path); loadBlocks(); if (m_dontWriteEmpty && ! m_positions.size()) { closeDatabase(); return; } createImage(); renderMap(); closeDatabase(); if (m_drawScale) { renderScale(); } if (m_drawOrigin) { renderOrigin(); } if (m_drawPlayers) { renderPlayers(input_path); } writeImage(output); printUnknown(); } void TileGenerator::parseColorsStream(std::istream &in) { char line[128]; while (in.good()) { in.getline(line, 128); for(char *p = line; *p; p++) { if(*p != '#') continue; *p = '\0'; // Cut off at the first # break; } if(strlen(line) == 0) continue; char name[64 + 1]; unsigned int r, g, b, a, t; a = 255; t = 0; int items = sscanf(line, "%64s %u %u %u %u %u", name, &r, &g, &b, &a, &t); if(items < 4) { std::cerr << "Failed to parse color entry '" << line << "'" << std::endl; continue; } ColorEntry color = ColorEntry(r, g, b, a, t); m_colorMap[name] = color; } } void TileGenerator::openDb(const std::string &input) { std::string backend = m_backend; if(backend == "") { std::ifstream ifs((input + "/world.mt").c_str()); if(!ifs.good()) throw std::runtime_error("Failed to read world.mt"); backend = read_setting("backend", ifs); ifs.close(); } if(backend == "sqlite3") m_db = new DBSQLite3(input); #if USE_POSTGRESQL else if(backend == "postgresql") m_db = new DBPostgreSQL(input); #endif #if USE_LEVELDB else if(backend == "leveldb") m_db = new DBLevelDB(input); #endif #if USE_REDIS else if(backend == "redis") m_db = new DBRedis(input); #endif else throw std::runtime_error(((std::string) "Unknown map backend: ") + backend); } void TileGenerator::closeDatabase() { delete m_db; m_db = NULL; } void TileGenerator::loadBlocks() { std::vector vec = m_db->getBlockPos(); for (std::vector::iterator it = vec.begin(); it != vec.end(); ++it) { BlockPos pos = *it; // Check that it's in geometry (from --geometry option) if (pos.x < m_geomX || pos.x >= m_geomX2 || pos.z < m_geomY || pos.z >= m_geomY2) continue; // Check that it's between --min-y and --max-y if (pos.y * 16 < m_yMin || pos.y * 16 > m_yMax) continue; // Adjust minimum and maximum positions to the nearest block if (pos.x < m_xMin) m_xMin = pos.x; if (pos.x > m_xMax) m_xMax = pos.x; if (pos.z < m_zMin) m_zMin = pos.z; if (pos.z > m_zMax) m_zMax = pos.z; m_positions.push_back(std::pair(pos.x, pos.z)); } m_positions.sort(); m_positions.unique(); } void TileGenerator::createImage() { const int scale_d = 40; // pixels reserved for a scale if(!m_drawScale) m_scales = 0; // If a geometry is explicitly set, set the bounding box to the requested geometry // instead of cropping to the content. This way we will always output a full tile // of the correct size. if (m_geomX > -2048 && m_geomX2 < 2048) { m_xMin = m_geomX; m_xMax = m_geomX2-1; } if (m_geomY > -2048 && m_geomY2 < 2048) { m_zMin = m_geomY; m_zMax = m_geomY2-1; } m_mapWidth = (m_xMax - m_xMin + 1) * 16; m_mapHeight = (m_zMax - m_zMin + 1) * 16; m_xBorder = (m_scales & SCALE_LEFT) ? scale_d : 0; m_yBorder = (m_scales & SCALE_TOP) ? scale_d : 0; m_blockPixelAttributes.setWidth(m_mapWidth); int image_width, image_height; image_width = (m_mapWidth * m_zoom) + m_xBorder; image_width += (m_scales & SCALE_RIGHT) ? scale_d : 0; image_height = (m_mapHeight * m_zoom) + m_yBorder; image_height += (m_scales & SCALE_BOTTOM) ? scale_d : 0; if(image_width > 4096 || image_height > 4096) std::cerr << "Warning: The width or height of the image to be created exceeds 4096 pixels!" << " (Dimensions: " << image_width << "x" << image_height << ")" << std::endl; m_image = new Image(image_width, image_height); m_image->drawFilledRect(0, 0, image_width, image_height, m_bgColor); // Background } void TileGenerator::renderMap() { BlockDecoder blk; std::list zlist = getZValueList(); for (std::list::iterator zPosition = zlist.begin(); zPosition != zlist.end(); ++zPosition) { int zPos = *zPosition; std::map blocks; m_db->getBlocksOnZ(blocks, zPos); for (std::list >::const_iterator position = m_positions.begin(); position != m_positions.end(); ++position) { if (position->second != zPos) continue; m_readPixels.reset(); m_readInfo.reset(); for (int i = 0; i < 16; i++) { for (int j = 0; j < 16; j++) { m_color[i][j] = m_bgColor; // This will be drawn by renderMapBlockBottom() for y-rows with only 'air', 'ignore' or unknown nodes if --drawalpha is used m_color[i][j].a = 0; // ..but set alpha to 0 to tell renderMapBlock() not to use this color to mix a shade m_thickness[i][j] = 0; } } int xPos = position->first; blocks[xPos].sort(); const BlockList &blockStack = blocks[xPos]; for (BlockList::const_iterator it = blockStack.begin(); it != blockStack.end(); ++it) { const BlockPos &pos = it->first; blk.reset(); blk.decode(it->second); if (blk.isEmpty()) continue; renderMapBlock(blk, pos); // Exit out if all pixels for this MapBlock are covered if (m_readPixels.full()) break; } if (!m_readPixels.full()) renderMapBlockBottom(blockStack.begin()->first); } if (m_shading) renderShading(zPos); } } void TileGenerator::renderMapBlock(const BlockDecoder &blk, const BlockPos &pos) { int xBegin = (pos.x - m_xMin) * 16; int zBegin = (m_zMax - pos.z) * 16; int minY = (pos.y * 16 > m_yMin) ? 0 : m_yMin - pos.y * 16; int maxY = (pos.y * 16 < m_yMax) ? 15 : m_yMax - pos.y * 16; for (int z = 0; z < 16; ++z) { int imageY = zBegin + 15 - z; for (int x = 0; x < 16; ++x) { if (m_readPixels.get(x, z)) continue; int imageX = xBegin + x; for (int y = maxY; y >= minY; --y) { string name = blk.getNode(x, y, z); if (name == "") continue; ColorMap::const_iterator it = m_colorMap.find(name); if (it == m_colorMap.end()) { m_unknownNodes.insert(name); continue; } const Color c = it->second.to_color(); if (m_drawAlpha) { if (m_color[z][x].a == 0) m_color[z][x] = c; // first visible time, no color mixing else m_color[z][x] = mixColors(m_color[z][x], c); if(m_color[z][x].a < 0xff) { // near thickness value to thickness of current node m_thickness[z][x] = (m_thickness[z][x] + it->second.t) / 2.0; continue; } // color became opaque, draw it setZoomed(imageX, imageY, m_color[z][x]); m_blockPixelAttributes.attribute(15 - z, xBegin + x).thickness = m_thickness[z][x]; } else { setZoomed(imageX, imageY, c.noAlpha()); } m_readPixels.set(x, z); // do this afterwards so we can record height values // inside transparent nodes (water) too if (!m_readInfo.get(x, z)) { m_blockPixelAttributes.attribute(15 - z, xBegin + x).height = pos.y * 16 + y; m_readInfo.set(x, z); } break; } } } } void TileGenerator::renderMapBlockBottom(const BlockPos &pos) { if (!m_drawAlpha) return; // "missing" pixels can only happen with --drawalpha int xBegin = (pos.x - m_xMin) * 16; int zBegin = (m_zMax - pos.z) * 16; for (int z = 0; z < 16; ++z) { int imageY = zBegin + 15 - z; for (int x = 0; x < 16; ++x) { if (m_readPixels.get(x, z)) continue; int imageX = xBegin + x; // set color since it wasn't done in renderMapBlock() setZoomed(imageX, imageY, m_color[z][x]); m_readPixels.set(x, z); m_blockPixelAttributes.attribute(15 - z, xBegin + x).thickness = m_thickness[z][x]; } } } void TileGenerator::renderShading(int zPos) { int zBegin = (m_zMax - zPos) * 16; for (int z = 0; z < 16; ++z) { int imageY = zBegin + z; if (imageY >= m_mapHeight) continue; for (int x = 0; x < m_mapWidth; ++x) { if( !m_blockPixelAttributes.attribute(z, x).valid_height() || !m_blockPixelAttributes.attribute(z, x - 1).valid_height() || !m_blockPixelAttributes.attribute(z - 1, x).valid_height() ) continue; // calculate shadow to apply int y = m_blockPixelAttributes.attribute(z, x).height; int y1 = m_blockPixelAttributes.attribute(z, x - 1).height; int y2 = m_blockPixelAttributes.attribute(z - 1, x).height; int d = ((y - y1) + (y - y2)) * 12; if (m_drawAlpha) { // less visible shadow with increasing "thickness" double t = m_blockPixelAttributes.attribute(z, x).thickness * 1.2; d *= 1.0 - mymin(t, 255.0) / 255.0; } d = mymin(d, 36); Color c = m_image->getPixel(getImageX(x), getImageY(imageY)); c.r = colorSafeBounds(c.r + d); c.g = colorSafeBounds(c.g + d); c.b = colorSafeBounds(c.b + d); setZoomed(x, imageY, c); } } m_blockPixelAttributes.scroll(); } void TileGenerator::renderScale() { const int scale_d = 40; // see createImage() if (m_scales & SCALE_TOP) { m_image->drawText(24, 0, "X", m_scaleColor); for (int i = (m_xMin / 4) * 4; i <= m_xMax; i += 4) { std::ostringstream buf; buf << i * 16; int xPos = getImageX(i * 16, true); if (xPos >= 0) { m_image->drawText(xPos + 2, 0, buf.str(), m_scaleColor); m_image->drawLine(xPos, 0, xPos, m_yBorder - 1, m_scaleColor); } } } if (m_scales & SCALE_LEFT) { m_image->drawText(2, 24, "Z", m_scaleColor); for (int i = (m_zMax / 4) * 4; i >= m_zMin; i -= 4) { std::ostringstream buf; buf << i * 16; int yPos = getImageY(i * 16 + 1, true); if (yPos >= 0) { m_image->drawText(2, yPos, buf.str(), m_scaleColor); m_image->drawLine(0, yPos, m_xBorder - 1, yPos, m_scaleColor); } } } if (m_scales & SCALE_BOTTOM) { int xPos = m_xBorder + m_mapWidth*m_zoom - 24 - 8, yPos = m_yBorder + m_mapHeight*m_zoom + scale_d - 12; m_image->drawText(xPos, yPos, "X", m_scaleColor); for (int i = (m_xMin / 4) * 4; i <= m_xMax; i += 4) { std::ostringstream buf; buf << i * 16; xPos = getImageX(i * 16, true); yPos = m_yBorder + m_mapHeight*m_zoom; if (xPos >= 0) { m_image->drawText(xPos + 2, yPos, buf.str(), m_scaleColor); m_image->drawLine(xPos, yPos, xPos, yPos + 39, m_scaleColor); } } } if (m_scales & SCALE_RIGHT) { int xPos = m_xBorder + m_mapWidth*m_zoom + scale_d - 2 - 8, yPos = m_yBorder + m_mapHeight*m_zoom - 24 - 12; m_image->drawText(xPos, yPos, "Z", m_scaleColor); for (int i = (m_zMax / 4) * 4; i >= m_zMin; i -= 4) { std::ostringstream buf; buf << i * 16; xPos = m_xBorder + m_mapWidth*m_zoom; yPos = getImageY(i * 16 + 1, true); if (yPos >= 0) { m_image->drawText(xPos + 2, yPos, buf.str(), m_scaleColor); m_image->drawLine(xPos, yPos, xPos + 39, yPos, m_scaleColor); } } } } void TileGenerator::renderOrigin() { if (m_xMin > 0 || m_xMax < 0 || m_zMin > 0 || m_zMax < 0) return; m_image->drawCircle(getImageX(0, true), getImageY(0, true), 12, m_originColor); } void TileGenerator::renderPlayers(const std::string &inputPath) { PlayerAttributes players(inputPath); for (PlayerAttributes::Players::iterator player = players.begin(); player != players.end(); ++player) { if (player->x < m_xMin * 16 || player->x > m_xMax * 16 || player->z < m_zMin * 16 || player->z > m_zMax * 16) continue; if (player->y < m_yMin || player->y > m_yMax) continue; int imageX = getImageX(player->x, true), imageY = getImageY(player->z, true); m_image->drawFilledRect(imageX - 1, imageY, 3, 1, m_playerColor); m_image->drawFilledRect(imageX, imageY - 1, 1, 3, m_playerColor); m_image->drawText(imageX + 2, imageY, player->name, m_playerColor); } } inline std::list TileGenerator::getZValueList() const { std::list zlist; for (std::list >::const_iterator position = m_positions.begin(); position != m_positions.end(); ++position) zlist.push_back(position->second); zlist.sort(); zlist.unique(); zlist.reverse(); return zlist; } void TileGenerator::writeImage(const std::string &output) { m_image->save(output); delete m_image; m_image = NULL; } void TileGenerator::printUnknown() { if (m_unknownNodes.size() == 0) return; std::cerr << "Unknown nodes:" << std::endl; for (NameSet::iterator node = m_unknownNodes.begin(); node != m_unknownNodes.end(); ++node) std::cerr << "\t" << *node << std::endl; } inline int TileGenerator::getImageX(int val, bool absolute) const { if (absolute) val = (val - m_xMin * 16); return (m_zoom*val) + m_xBorder; } inline int TileGenerator::getImageY(int val, bool absolute) const { if (absolute) val = m_mapHeight - (val - m_zMin * 16); // Z axis is flipped on image return (m_zoom*val) + m_yBorder; } inline void TileGenerator::setZoomed(int x, int y, Color color) { m_image->drawFilledRect(getImageX(x), getImageY(y), m_zoom, m_zoom, color); } minetestmapper-20191011/ZlibDecompressor.cpp000066400000000000000000000027641355015577700210310ustar00rootroot00000000000000/* * ===================================================================== * Version: 1.0 * Created: 18.09.2012 10:20:47 * Author: Miroslav Bendík * Company: LinuxOS.sk * ===================================================================== */ #include #include #include "ZlibDecompressor.h" ZlibDecompressor::ZlibDecompressor(const unsigned char *data, std::size_t size): m_data(data), m_seekPos(0), m_size(size) { } ZlibDecompressor::~ZlibDecompressor() { } void ZlibDecompressor::setSeekPos(std::size_t seekPos) { m_seekPos = seekPos; } std::size_t ZlibDecompressor::seekPos() const { return m_seekPos; } ustring ZlibDecompressor::decompress() { const unsigned char *data = m_data + m_seekPos; const std::size_t size = m_size - m_seekPos; ustring buffer; const size_t BUFSIZE = 128 * 1024; uint8_t temp_buffer[BUFSIZE]; z_stream strm; strm.zalloc = Z_NULL; strm.zfree = Z_NULL; strm.opaque = Z_NULL; strm.next_in = Z_NULL; strm.avail_in = size; if (inflateInit(&strm) != Z_OK) { throw DecompressError(); } strm.next_in = const_cast(data); int ret = 0; do { strm.avail_out = BUFSIZE; strm.next_out = temp_buffer; ret = inflate(&strm, Z_NO_FLUSH); buffer += ustring(reinterpret_cast(temp_buffer), BUFSIZE - strm.avail_out); } while (ret == Z_OK); if (ret != Z_STREAM_END) { throw DecompressError(); } m_seekPos += strm.next_in - data; (void)inflateEnd(&strm); return buffer; } minetestmapper-20191011/autogenerating-colors.txt000066400000000000000000000074701355015577700221120ustar00rootroot00000000000000==FILE== mods/dumpnodes/init.lua local function nd_get_tiles(nd) return nd.tiles or nd.tile_images end local function nd_get_tile(nd, n) local tile = nd_get_tiles(nd)[n] if type(tile) == 'table' then tile = tile.name end return tile end local function pairs_s(dict) local keys = {} for k in pairs(dict) do table.insert(keys, k) end table.sort(keys) return ipairs(keys) end minetest.register_chatcommand("dumpnodes", { params = "", description = "", func = function(player, param) local n = 0 local ntbl = {} for _, nn in pairs_s(minetest.registered_nodes) do local nd = minetest.registered_nodes[nn] local prefix, name = nn:match('(.*):(.*)') if prefix == nil or name == nil then print("ignored(1): " .. nn) else if ntbl[prefix] == nil then ntbl[prefix] = {} end ntbl[prefix][name] = true end end local out, err = io.open('nodes.txt', 'wb') if not out then return true, "io.open(): " .. err end for _, prefix in pairs_s(ntbl) do out:write('# ' .. prefix .. '\n') for _, name in pairs_s(ntbl[prefix]) do local nn = prefix .. ":" .. name local nd = minetest.registered_nodes[nn] if nd.drawtype == 'airlike' or nd_get_tiles(nd) == nil then print("ignored(2): " .. nn) else local tl = nd_get_tile(nd, 1) tl = (tl .. '^'):match('(.-)^') -- strip modifiers out:write(nn .. ' ' .. tl .. '\n') n = n + 1 end end out:write('\n') end out:close() return true, n .. " nodes dumped." end, }) ==FILE== avgcolor.py #!/usr/bin/env python import sys from math import sqrt from PIL import Image if len(sys.argv) < 2: print("Prints average color (RGB) of input image") print("Usage: %s " % sys.argv[0]) exit(1) inp = Image.open(sys.argv[1]).convert('RGBA') ind = inp.load() cl = ([], [], []) for x in range(inp.size[0]): for y in range(inp.size[1]): px = ind[x, y] if px[3] < 128: continue # alpha cl[0].append(px[0]**2) cl[1].append(px[1]**2) cl[2].append(px[2]**2) if len(cl[0]) == 0: print("Didn't find average color for %s" % sys.argv[1], file=sys.stderr) print("0 0 0") else: cl = tuple(sqrt(sum(x)/len(x)) for x in cl) print("%d %d %d" % cl) ==SCRIPT== #!/bin/bash -e AVGCOLOR_PATH=/path/to/avgcolor.py GAME_PATH=/path/to/minetest_game MODS_PATH= # path to "mods" folder, only set if you have loaded mods NODESTXT_PATH=./nodes.txt COLORSTXT_PATH=./colors.txt while read -r line; do set -- junk $line; shift if [[ -z "$1" || $1 == "#" ]]; then echo "$line"; continue fi tex=$(find $GAME_PATH -type f -name "$2") [[ -z "$tex" && -n "$MODS_PATH" ]] && tex=$(find $MODS_PATH -type f -name "$2") if [ -z "$tex" ]; then echo "skip $1: texture not found" >&2 continue fi echo "$1" $(python $AVGCOLOR_PATH "$tex") echo "ok $1" >&2 done < $NODESTXT_PATH > $COLORSTXT_PATH # Use nicer colors for water and lava: sed -re 's/^default:((river_)?water_(flowing|source)) [0-9 ]+$/default:\1 39 66 106 128 224/g' $COLORSTXT_PATH -i sed -re 's/^default:(lava_(flowing|source)) [0-9 ]+$/default:\1 255 100 0/g' $COLORSTXT_PATH -i # Add transparency to glass nodes and xpanes: sed -re 's/^default:(.*glass) ([0-9 ]+)$/default:\1 \2 64 16/g' $COLORSTXT_PATH -i sed -re 's/^doors:(.*glass[^ ]*) ([0-9 ]+)$/doors:\1 \2 64 16/g' $COLORSTXT_PATH -i sed -re 's/^xpanes:(.*(pane|bar)[^ ]*) ([0-9 ]+)$/xpanes:\1 \3 64 16/g' $COLORSTXT_PATH -i # Delete some usually hidden nodes: sed '/^doors:hidden /d' $COLORSTXT_PATH -i sed '/^fireflies:firefly /d' $COLORSTXT_PATH -i sed '/^butterflies:butterfly_/d' $COLORSTXT_PATH -i ==INSTRUCTIONS== 1) Make sure avgcolors.py works (outputs the usage instructions when run) 2) Add the dumpnodes mod to Minetest 3) Create a world and load dumpnodes & all mods you want to generate colors for 4) Execute /dumpnodes ingame 5) Run the script to generate colors.txt (make sure to adjust the PATH variables at the top) minetestmapper-20191011/colors.txt000066400000000000000000000334341355015577700170770ustar00rootroot00000000000000# beds beds:bed_bottom 130 3 3 beds:bed_top 185 162 163 beds:fancy_bed_bottom 136 49 28 beds:fancy_bed_top 179 153 148 # bones bones:bones 117 117 117 # butterflies # carts carts:brakerail 138 121 102 carts:powerrail 160 145 102 carts:rail 146 128 108 # default default:acacia_bush_leaves 109 133 87 default:acacia_bush_sapling 85 121 61 default:acacia_bush_stem 84 77 70 default:acacia_leaves 126 153 101 default:acacia_sapling 87 120 64 default:acacia_tree 195 119 97 default:acacia_wood 150 61 39 default:apple 161 34 19 default:aspen_leaves 72 105 29 default:aspen_sapling 85 123 45 default:aspen_tree 218 198 168 default:aspen_wood 210 199 170 default:blueberry_bush_leaves 63 99 22 default:blueberry_bush_leaves_with_berries 63 99 22 default:blueberry_bush_sapling 81 112 33 default:bookshelf 131 102 57 default:brick 123 99 95 default:bronzeblock 186 111 15 default:bush_leaves 35 55 29 default:bush_sapling 66 64 40 default:bush_stem 46 34 24 default:cactus 70 119 52 default:cave_ice 168 206 247 default:chest 149 115 69 default:chest_locked 149 115 69 default:chest_locked_open 149 115 69 default:chest_open 149 115 69 default:clay 183 183 183 default:cloud 255 255 255 default:coalblock 58 58 58 default:cobble 89 86 84 default:copperblock 193 126 65 default:coral_brown 146 113 77 default:coral_cyan 235 230 215 default:coral_green 235 230 215 default:coral_orange 197 68 17 default:coral_pink 235 230 215 default:coral_skeleton 235 230 215 default:desert_cobble 110 67 50 default:desert_sand 206 165 98 default:desert_sandstone 195 152 92 default:desert_sandstone_block 193 152 94 default:desert_sandstone_brick 191 151 95 default:desert_stone 130 79 61 default:desert_stone_block 131 80 61 default:desert_stonebrick 131 80 61 default:diamondblock 140 218 223 default:dirt 97 67 43 default:dirt_with_coniferous_litter 109 90 71 default:dirt_with_dry_grass 187 148 78 default:dirt_with_grass 64 111 26 default:dirt_with_grass_footsteps 64 111 26 default:dirt_with_rainforest_litter 76 39 10 default:dirt_with_snow 225 225 238 default:dry_dirt 178 136 90 default:dry_dirt_with_dry_grass 187 148 78 default:dry_grass_1 208 172 87 default:dry_grass_2 210 174 87 default:dry_grass_3 210 174 87 default:dry_grass_4 211 175 88 default:dry_grass_5 214 178 92 default:dry_shrub 103 67 18 default:emergent_jungle_sapling 51 40 16 default:fence_acacia_wood 151 62 39 default:fence_aspen_wood 210 199 170 default:fence_junglewood 57 39 14 default:fence_pine_wood 221 185 131 default:fence_rail_acacia_wood 150 61 39 default:fence_rail_aspen_wood 209 198 170 default:fence_rail_junglewood 56 39 14 default:fence_rail_pine_wood 221 184 130 default:fence_rail_wood 131 102 57 default:fence_wood 132 103 57 default:fern_1 85 118 51 default:fern_2 90 123 53 default:fern_3 91 125 54 default:furnace 101 98 96 default:furnace_active 101 98 96 default:glass 247 247 247 64 16 default:goldblock 231 203 35 default:grass_1 100 140 54 default:grass_2 98 139 55 default:grass_3 94 136 53 default:grass_4 89 133 48 default:grass_5 86 126 48 default:gravel 132 132 132 default:ice 168 206 247 default:junglegrass 67 110 28 default:jungleleaves 22 31 16 default:junglesapling 51 39 15 default:jungletree 121 97 62 default:junglewood 56 39 14 default:ladder_steel 132 132 132 default:ladder_wood 125 93 43 default:large_cactus_seedling 67 107 52 default:lava_flowing 255 100 0 default:lava_source 255 100 0 default:leaves 36 55 29 default:marram_grass_1 113 139 96 default:marram_grass_2 102 131 90 default:marram_grass_3 99 130 88 default:mese 222 222 0 default:mese_post_light 134 105 59 default:meselamp 213 215 143 default:mossycobble 88 91 73 default:obsidian 21 24 29 default:obsidian_block 23 25 30 default:obsidian_glass 20 23 27 64 16 default:obsidianbrick 23 25 29 default:papyrus 97 134 38 default:permafrost 71 66 61 default:permafrost_with_moss 108 150 51 default:permafrost_with_stones 71 66 61 default:pine_bush_needles 16 50 19 default:pine_bush_sapling 58 51 40 default:pine_bush_stem 73 62 53 default:pine_needles 16 50 19 default:pine_sapling 41 48 26 default:pine_tree 191 165 132 default:pine_wood 221 185 130 default:river_water_flowing 39 66 106 128 224 default:river_water_source 39 66 106 128 224 default:sand 214 207 158 default:sand_with_kelp 214 207 158 default:sandstone 198 193 143 default:sandstone_block 195 191 142 default:sandstonebrick 194 190 141 default:sapling 67 63 41 default:sign_wall_steel 147 147 147 default:sign_wall_wood 148 103 66 default:silver_sand 193 191 179 default:silver_sandstone 195 192 181 default:silver_sandstone_block 192 190 180 default:silver_sandstone_brick 191 189 179 default:snow 225 225 238 default:snowblock 225 225 238 default:steelblock 195 195 195 default:stone 97 94 93 default:stone_block 100 97 96 default:stone_with_coal 97 94 93 default:stone_with_copper 97 94 93 default:stone_with_diamond 97 94 93 default:stone_with_gold 97 94 93 default:stone_with_iron 97 94 93 default:stone_with_mese 97 94 93 default:stone_with_tin 97 94 93 default:stonebrick 102 99 98 default:tinblock 150 150 150 default:torch 141 123 93 default:torch_ceiling 141 123 93 default:torch_wall 141 123 93 default:tree 179 145 99 default:water_flowing 39 66 106 128 224 default:water_source 39 66 106 128 224 default:wood 131 102 57 # doors doors:door_glass_a 245 245 245 64 16 doors:door_glass_b 245 245 245 64 16 doors:door_obsidian_glass_a 48 49 50 64 16 doors:door_obsidian_glass_b 48 49 50 64 16 doors:door_steel_a 203 203 203 doors:door_steel_b 203 203 203 doors:door_wood_a 89 68 37 doors:door_wood_b 89 68 37 doors:gate_acacia_wood_closed 150 61 39 doors:gate_acacia_wood_open 150 61 39 doors:gate_aspen_wood_closed 210 199 170 doors:gate_aspen_wood_open 210 199 170 doors:gate_junglewood_closed 56 39 14 doors:gate_junglewood_open 56 39 14 doors:gate_pine_wood_closed 221 185 130 doors:gate_pine_wood_open 221 185 130 doors:gate_wood_closed 131 102 57 doors:gate_wood_open 131 102 57 doors:trapdoor 130 100 51 doors:trapdoor_open 68 53 30 doors:trapdoor_steel 200 200 200 doors:trapdoor_steel_open 97 97 97 # farming farming:cotton_1 89 117 39 farming:cotton_2 89 116 38 farming:cotton_3 99 121 41 farming:cotton_4 108 114 47 farming:cotton_5 116 105 53 farming:cotton_6 121 95 59 farming:cotton_7 94 70 37 farming:cotton_8 122 108 93 farming:desert_sand_soil 161 132 72 farming:desert_sand_soil_wet 120 99 53 farming:dry_soil 178 136 90 farming:dry_soil_wet 178 136 90 farming:seed_cotton 92 87 60 farming:seed_wheat 177 161 96 farming:soil 97 67 43 farming:soil_wet 97 67 43 farming:straw 212 184 68 farming:wheat_1 110 175 36 farming:wheat_2 136 177 53 farming:wheat_3 163 182 84 farming:wheat_4 170 188 95 farming:wheat_5 171 179 97 farming:wheat_6 173 177 87 farming:wheat_7 193 181 83 farming:wheat_8 187 162 40 # fire fire:basic_flame 223 136 44 fire:permanent_flame 223 136 44 # fireflies fireflies:firefly_bottle 191 194 202 # flowers flowers:chrysanthemum_green 118 152 44 flowers:dandelion_white 199 191 176 flowers:dandelion_yellow 212 167 31 flowers:geranium 77 91 168 flowers:mushroom_brown 109 84 78 flowers:mushroom_red 195 102 102 flowers:rose 130 68 33 flowers:tulip 156 101 44 flowers:tulip_black 78 120 72 flowers:viola 115 69 184 flowers:waterlily 107 160 68 flowers:waterlily_waving 107 160 68 # stairs stairs:slab_acacia_wood 150 61 39 stairs:slab_aspen_wood 210 199 170 stairs:slab_brick 123 99 95 stairs:slab_bronzeblock 186 111 15 stairs:slab_cobble 89 86 84 stairs:slab_copperblock 193 126 65 stairs:slab_desert_cobble 110 67 50 stairs:slab_desert_sandstone 195 152 92 stairs:slab_desert_sandstone_block 193 152 94 stairs:slab_desert_sandstone_brick 191 151 95 stairs:slab_desert_stone 130 79 61 stairs:slab_desert_stone_block 131 80 61 stairs:slab_desert_stonebrick 131 80 61 stairs:slab_glass 247 247 247 stairs:slab_goldblock 231 203 35 stairs:slab_ice 168 206 247 stairs:slab_junglewood 56 39 14 stairs:slab_mossycobble 88 91 73 stairs:slab_obsidian 21 24 29 stairs:slab_obsidian_block 23 25 30 stairs:slab_obsidian_glass 20 23 27 stairs:slab_obsidianbrick 23 25 29 stairs:slab_pine_wood 221 185 130 stairs:slab_sandstone 198 193 143 stairs:slab_sandstone_block 195 191 142 stairs:slab_sandstonebrick 194 190 141 stairs:slab_silver_sandstone 195 192 181 stairs:slab_silver_sandstone_block 192 190 180 stairs:slab_silver_sandstone_brick 191 189 179 stairs:slab_snowblock 225 225 238 stairs:slab_steelblock 195 195 195 stairs:slab_stone 97 94 93 stairs:slab_stone_block 100 97 96 stairs:slab_stonebrick 102 99 98 stairs:slab_straw 212 184 68 stairs:slab_tinblock 150 150 150 stairs:slab_wood 131 102 57 stairs:stair_acacia_wood 150 61 39 stairs:stair_aspen_wood 210 199 170 stairs:stair_brick 123 99 95 stairs:stair_bronzeblock 186 111 15 stairs:stair_cobble 89 86 84 stairs:stair_copperblock 193 126 65 stairs:stair_desert_cobble 110 67 50 stairs:stair_desert_sandstone 195 152 92 stairs:stair_desert_sandstone_block 193 152 94 stairs:stair_desert_sandstone_brick 191 151 95 stairs:stair_desert_stone 130 79 61 stairs:stair_desert_stone_block 131 80 61 stairs:stair_desert_stonebrick 131 80 61 stairs:stair_glass 249 249 249 stairs:stair_goldblock 231 203 35 stairs:stair_ice 168 206 247 stairs:stair_inner_acacia_wood 150 61 39 stairs:stair_inner_aspen_wood 210 199 170 stairs:stair_inner_brick 123 99 95 stairs:stair_inner_bronzeblock 186 111 15 stairs:stair_inner_cobble 89 86 84 stairs:stair_inner_copperblock 193 126 65 stairs:stair_inner_desert_cobble 110 67 50 stairs:stair_inner_desert_sandstone 195 152 92 stairs:stair_inner_desert_sandstone_block 193 152 94 stairs:stair_inner_desert_sandstone_brick 191 151 95 stairs:stair_inner_desert_stone 130 79 61 stairs:stair_inner_desert_stone_block 131 80 61 stairs:stair_inner_desert_stonebrick 131 80 61 stairs:stair_inner_glass 250 250 250 stairs:stair_inner_goldblock 231 203 35 stairs:stair_inner_ice 168 206 247 stairs:stair_inner_junglewood 56 39 14 stairs:stair_inner_mossycobble 88 91 73 stairs:stair_inner_obsidian 21 24 29 stairs:stair_inner_obsidian_block 23 25 30 stairs:stair_inner_obsidian_glass 20 22 27 stairs:stair_inner_obsidianbrick 23 25 29 stairs:stair_inner_pine_wood 221 185 130 stairs:stair_inner_sandstone 198 193 143 stairs:stair_inner_sandstone_block 195 191 142 stairs:stair_inner_sandstonebrick 194 190 141 stairs:stair_inner_silver_sandstone 195 192 181 stairs:stair_inner_silver_sandstone_block 192 190 180 stairs:stair_inner_silver_sandstone_brick 191 189 179 stairs:stair_inner_snowblock 225 225 238 stairs:stair_inner_steelblock 195 195 195 stairs:stair_inner_stone 97 94 93 stairs:stair_inner_stone_block 100 97 96 stairs:stair_inner_stonebrick 102 99 98 stairs:stair_inner_straw 212 184 68 stairs:stair_inner_tinblock 150 150 150 stairs:stair_inner_wood 131 102 57 stairs:stair_junglewood 56 39 14 stairs:stair_mossycobble 88 91 73 stairs:stair_obsidian 21 24 29 stairs:stair_obsidian_block 23 25 30 stairs:stair_obsidian_glass 20 22 27 stairs:stair_obsidianbrick 23 25 29 stairs:stair_outer_acacia_wood 150 61 39 stairs:stair_outer_aspen_wood 210 199 170 stairs:stair_outer_brick 123 99 95 stairs:stair_outer_bronzeblock 186 111 15 stairs:stair_outer_cobble 89 86 84 stairs:stair_outer_copperblock 193 126 65 stairs:stair_outer_desert_cobble 110 67 50 stairs:stair_outer_desert_sandstone 195 152 92 stairs:stair_outer_desert_sandstone_block 193 152 94 stairs:stair_outer_desert_sandstone_brick 191 151 95 stairs:stair_outer_desert_stone 130 79 61 stairs:stair_outer_desert_stone_block 131 80 61 stairs:stair_outer_desert_stonebrick 131 80 61 stairs:stair_outer_glass 250 250 250 stairs:stair_outer_goldblock 231 203 35 stairs:stair_outer_ice 168 206 247 stairs:stair_outer_junglewood 56 39 14 stairs:stair_outer_mossycobble 88 91 73 stairs:stair_outer_obsidian 21 24 29 stairs:stair_outer_obsidian_block 23 25 30 stairs:stair_outer_obsidian_glass 20 22 27 stairs:stair_outer_obsidianbrick 23 25 29 stairs:stair_outer_pine_wood 221 185 130 stairs:stair_outer_sandstone 198 193 143 stairs:stair_outer_sandstone_block 195 191 142 stairs:stair_outer_sandstonebrick 194 190 141 stairs:stair_outer_silver_sandstone 195 192 181 stairs:stair_outer_silver_sandstone_block 192 190 180 stairs:stair_outer_silver_sandstone_brick 191 189 179 stairs:stair_outer_snowblock 225 225 238 stairs:stair_outer_steelblock 195 195 195 stairs:stair_outer_stone 97 94 93 stairs:stair_outer_stone_block 100 97 96 stairs:stair_outer_stonebrick 102 99 98 stairs:stair_outer_straw 212 184 68 stairs:stair_outer_tinblock 150 150 150 stairs:stair_outer_wood 131 102 57 stairs:stair_pine_wood 221 185 130 stairs:stair_sandstone 198 193 143 stairs:stair_sandstone_block 195 191 142 stairs:stair_sandstonebrick 194 190 141 stairs:stair_silver_sandstone 195 192 181 stairs:stair_silver_sandstone_block 192 190 180 stairs:stair_silver_sandstone_brick 191 189 179 stairs:stair_snowblock 225 225 238 stairs:stair_steelblock 195 195 195 stairs:stair_stone 97 94 93 stairs:stair_stone_block 100 97 96 stairs:stair_stonebrick 102 99 98 stairs:stair_straw 212 184 68 stairs:stair_tinblock 150 150 150 stairs:stair_wood 131 102 57 # tnt tnt:gunpowder 12 12 12 tnt:gunpowder_burning 156 143 7 tnt:tnt 196 0 0 tnt:tnt_burning 201 41 0 # vessels vessels:drinking_glass 207 214 228 vessels:glass_bottle 189 192 204 vessels:shelf 131 102 57 vessels:steel_bottle 194 193 193 # walls walls:cobble 89 86 84 walls:desertcobble 110 67 50 walls:mossycobble 88 91 73 # wool wool:black 30 30 30 wool:blue 0 73 146 wool:brown 88 44 0 wool:cyan 0 132 140 wool:dark_green 33 103 0 wool:dark_grey 60 60 60 wool:green 93 218 28 wool:grey 133 133 133 wool:magenta 201 3 112 wool:orange 214 83 22 wool:pink 255 133 133 wool:red 170 18 18 wool:violet 93 5 169 wool:white 220 220 220 wool:yellow 254 226 16 # xpanes xpanes:bar 114 114 114 64 16 xpanes:bar_flat 114 114 114 64 16 xpanes:door_steel_bar_a 133 133 133 64 16 xpanes:door_steel_bar_b 133 133 133 64 16 xpanes:obsidian_pane 16 17 18 64 16 xpanes:obsidian_pane_flat 16 17 18 64 16 xpanes:pane 249 249 249 64 16 xpanes:pane_flat 249 249 249 64 16 xpanes:trapdoor_steel_bar 127 127 127 64 16 xpanes:trapdoor_steel_bar_open 77 77 77 64 16 minetestmapper-20191011/db-leveldb.cpp000066400000000000000000000027401355015577700175350ustar00rootroot00000000000000#include #include #include "db-leveldb.h" #include "types.h" static inline int64_t stoi64(const std::string &s) { std::stringstream tmp(s); int64_t t; tmp >> t; return t; } static inline std::string i64tos(int64_t i) { std::ostringstream os; os << i; return os.str(); } DBLevelDB::DBLevelDB(const std::string &mapdir) { leveldb::Options options; options.create_if_missing = false; leveldb::Status status = leveldb::DB::Open(options, mapdir + "map.db", &db); if (!status.ok()) { throw std::runtime_error(std::string("Failed to open Database: ") + status.ToString()); } loadPosCache(); } DBLevelDB::~DBLevelDB() { delete db; } std::vector DBLevelDB::getBlockPos() { return posCache; } void DBLevelDB::loadPosCache() { leveldb::Iterator * it = db->NewIterator(leveldb::ReadOptions()); for (it->SeekToFirst(); it->Valid(); it->Next()) { int64_t posHash = stoi64(it->key().ToString()); posCache.push_back(decodeBlockPos(posHash)); } delete it; } void DBLevelDB::getBlocksOnZ(std::map &blocks, int16_t zPos) { std::string datastr; leveldb::Status status; for (std::vector::iterator it = posCache.begin(); it != posCache.end(); ++it) { if (it->z != zPos) { continue; } status = db->Get(leveldb::ReadOptions(), i64tos(encodeBlockPos(*it)), &datastr); if (status.ok()) { Block b(*it, ustring((const unsigned char *) datastr.data(), datastr.size())); blocks[b.first.x].push_back(b); } } } minetestmapper-20191011/db-postgresql.cpp000066400000000000000000000073051355015577700203250ustar00rootroot00000000000000#include #include #include #include #include #include "db-postgresql.h" #include "util.h" #include "types.h" #define ARRLEN(x) (sizeof(x) / sizeof((x)[0])) DBPostgreSQL::DBPostgreSQL(const std::string &mapdir) { std::ifstream ifs((mapdir + "/world.mt").c_str()); if(!ifs.good()) throw std::runtime_error("Failed to read world.mt"); std::string connect_string = read_setting("pgsql_connection", ifs); ifs.close(); db = PQconnectdb(connect_string.c_str()); if (PQstatus(db) != CONNECTION_OK) { throw std::runtime_error(std::string( "PostgreSQL database error: ") + PQerrorMessage(db) ); } prepareStatement( "get_block_pos", "SELECT posX, posY, posZ FROM blocks" ); prepareStatement( "get_blocks_z", "SELECT posX, posY, data FROM blocks WHERE posZ = $1::int4" ); checkResults(PQexec(db, "START TRANSACTION;")); checkResults(PQexec(db, "SET TRANSACTION ISOLATION LEVEL REPEATABLE READ;")); } DBPostgreSQL::~DBPostgreSQL() { try { checkResults(PQexec(db, "COMMIT;")); } catch (std::exception& caught) { std::cerr << "could not finalize: " << caught.what() << std::endl; } PQfinish(db); } std::vector DBPostgreSQL::getBlockPos() { std::vector positions; PGresult *results = execPrepared( "get_block_pos", 0, NULL, NULL, NULL, false, false ); int numrows = PQntuples(results); for (int row = 0; row < numrows; ++row) positions.push_back(pg_to_blockpos(results, row, 0)); PQclear(results); return positions; } void DBPostgreSQL::getBlocksOnZ(std::map &blocks, int16_t zPos) { int32_t const z = htonl(zPos); const void *args[] = { &z }; const int argLen[] = { sizeof(z) }; const int argFmt[] = { 1 }; PGresult *results = execPrepared( "get_blocks_z", ARRLEN(args), args, argLen, argFmt, false ); int numrows = PQntuples(results); for (int row = 0; row < numrows; ++row) { BlockPos position; position.x = pg_binary_to_int(results, row, 0); position.y = pg_binary_to_int(results, row, 1); position.z = zPos; Block const b( position, ustring( reinterpret_cast( PQgetvalue(results, row, 2) ), PQgetlength(results, row, 2) ) ); blocks[position.x].push_back(b); } PQclear(results); } PGresult *DBPostgreSQL::checkResults(PGresult *res, bool clear) { ExecStatusType statusType = PQresultStatus(res); switch (statusType) { case PGRES_COMMAND_OK: case PGRES_TUPLES_OK: break; case PGRES_FATAL_ERROR: throw std::runtime_error( std::string("PostgreSQL database error: ") + PQresultErrorMessage(res) ); default: throw std::runtime_error( "Unhandled PostgreSQL result code" ); } if (clear) PQclear(res); return res; } void DBPostgreSQL::prepareStatement(const std::string &name, const std::string &sql) { checkResults(PQprepare(db, name.c_str(), sql.c_str(), 0, NULL)); } PGresult *DBPostgreSQL::execPrepared( const char *stmtName, const int paramsNumber, const void **params, const int *paramsLengths, const int *paramsFormats, bool clear, bool nobinary ) { return checkResults(PQexecPrepared(db, stmtName, paramsNumber, (const char* const*) params, paramsLengths, paramsFormats, nobinary ? 1 : 0), clear ); } int DBPostgreSQL::pg_to_int(PGresult *res, int row, int col) { return atoi(PQgetvalue(res, row, col)); } int DBPostgreSQL::pg_binary_to_int(PGresult *res, int row, int col) { int32_t* raw = reinterpret_cast(PQgetvalue(res, row, col)); return ntohl(*raw); } BlockPos DBPostgreSQL::pg_to_blockpos(PGresult *res, int row, int col) { BlockPos result; result.x = pg_to_int(res, row, col); result.y = pg_to_int(res, row, col + 1); result.z = pg_to_int(res, row, col + 2); return result; } minetestmapper-20191011/db-redis.cpp000066400000000000000000000110031355015577700172160ustar00rootroot00000000000000#include #include #include #include "db-redis.h" #include "types.h" #include "util.h" #define DB_REDIS_HMGET_NUMFIELDS 30 #define REPLY_TYPE_ERR(reply, desc) do { \ throw std::runtime_error(std::string("Unexpected type for " desc ": ") \ + replyTypeStr((reply)->type)); \ } while(0) static inline int64_t stoi64(const std::string &s) { std::stringstream tmp(s); int64_t t; tmp >> t; return t; } static inline std::string i64tos(int64_t i) { std::ostringstream os; os << i; return os.str(); } DBRedis::DBRedis(const std::string &mapdir) { std::ifstream ifs((mapdir + "/world.mt").c_str()); if(!ifs.good()) throw std::runtime_error("Failed to read world.mt"); std::string tmp; tmp = read_setting("redis_address", ifs); ifs.seekg(0); hash = read_setting("redis_hash", ifs); ifs.seekg(0); const char *addr = tmp.c_str(); int port = stoi64(read_setting_default("redis_port", ifs, "6379")); ctx = tmp.find('/') != std::string::npos ? redisConnectUnix(addr) : redisConnect(addr, port); if(!ctx) { throw std::runtime_error("Cannot allocate redis context"); } else if(ctx->err) { std::string err = std::string("Connection error: ") + ctx->errstr; redisFree(ctx); throw std::runtime_error(err); } loadPosCache(); } DBRedis::~DBRedis() { redisFree(ctx); } std::vector DBRedis::getBlockPos() { return posCache; } std::string DBRedis::replyTypeStr(int type) { switch(type) { case REDIS_REPLY_STATUS: return "REDIS_REPLY_STATUS"; case REDIS_REPLY_ERROR: return "REDIS_REPLY_ERROR"; case REDIS_REPLY_INTEGER: return "REDIS_REPLY_INTEGER"; case REDIS_REPLY_NIL: return "REDIS_REPLY_NIL"; case REDIS_REPLY_STRING: return "REDIS_REPLY_STRING"; case REDIS_REPLY_ARRAY: return "REDIS_REPLY_ARRAY"; default: return "unknown"; } } void DBRedis::loadPosCache() { redisReply *reply; reply = (redisReply*) redisCommand(ctx, "HKEYS %s", hash.c_str()); if(!reply) throw std::runtime_error("Redis command HKEYS failed"); if(reply->type != REDIS_REPLY_ARRAY) REPLY_TYPE_ERR(reply, "HKEYS reply"); for(size_t i = 0; i < reply->elements; i++) { if(reply->element[i]->type != REDIS_REPLY_STRING) REPLY_TYPE_ERR(reply->element[i], "HKEYS subreply"); posCache.push_back(decodeBlockPos(stoi64(reply->element[i]->str))); } freeReplyObject(reply); } void DBRedis::HMGET(const std::vector &positions, std::vector *result) { const char *argv[DB_REDIS_HMGET_NUMFIELDS + 2]; argv[0] = "HMGET"; argv[1] = hash.c_str(); std::vector::const_iterator position = positions.begin(); std::size_t remaining = positions.size(); while (remaining > 0) { const std::size_t batch_size = (remaining > DB_REDIS_HMGET_NUMFIELDS) ? DB_REDIS_HMGET_NUMFIELDS : remaining; redisReply *reply; { // storage to preserve validity of .c_str() std::string keys[batch_size]; for (std::size_t i = 0; i < batch_size; ++i) { keys[i] = i64tos(encodeBlockPos(*position++)); argv[i+2] = keys[i].c_str(); } reply = (redisReply*) redisCommandArgv(ctx, batch_size + 2, argv, NULL); } if(!reply) throw std::runtime_error("Redis command HMGET failed"); if (reply->type != REDIS_REPLY_ARRAY) { freeReplyObject(reply); REPLY_TYPE_ERR(reply, "HKEYS subreply"); } if (reply->elements != batch_size) { freeReplyObject(reply); throw std::runtime_error("HMGET wrong number of elements"); } for (std::size_t i = 0; i < batch_size; ++i) { redisReply *subreply = reply->element[i]; if(!subreply) throw std::runtime_error("Redis command HMGET failed"); if (subreply->type != REDIS_REPLY_STRING) { freeReplyObject(reply); REPLY_TYPE_ERR(reply, "HKEYS subreply"); } if (subreply->len == 0) { freeReplyObject(reply); throw std::runtime_error("HMGET empty string"); } result->push_back(ustring((const unsigned char *) subreply->str, subreply->len)); } freeReplyObject(reply); remaining -= batch_size; } } void DBRedis::getBlocksOnZ(std::map &blocks, int16_t zPos) { std::vector z_positions; for (std::vector::const_iterator it = posCache.begin(); it != posCache.end(); ++it) { if (it->z != zPos) { continue; } z_positions.push_back(*it); } std::vector z_blocks; HMGET(z_positions, &z_blocks); std::vector::const_iterator z_block = z_blocks.begin(); for (std::vector::const_iterator pos = z_positions.begin(); pos != z_positions.end(); ++pos, ++z_block) { blocks[pos->x].push_back(Block(*pos, *z_block)); } } minetestmapper-20191011/db-sqlite3.cpp000066400000000000000000000046011355015577700175020ustar00rootroot00000000000000#include #include // for usleep #include #include "db-sqlite3.h" #include "types.h" #define SQLRES(f, good) \ result = (sqlite3_##f);\ if (result != good) {\ throw std::runtime_error(sqlite3_errmsg(db));\ } #define SQLOK(f) SQLRES(f, SQLITE_OK) DBSQLite3::DBSQLite3(const std::string &mapdir) { int result; std::string db_name = mapdir + "map.sqlite"; SQLOK(open_v2(db_name.c_str(), &db, SQLITE_OPEN_READONLY | SQLITE_OPEN_PRIVATECACHE, 0)) SQLOK(prepare_v2(db, "SELECT pos, data FROM blocks WHERE pos BETWEEN ? AND ?", -1, &stmt_get_blocks_z, NULL)) SQLOK(prepare_v2(db, "SELECT pos FROM blocks", -1, &stmt_get_block_pos, NULL)) } DBSQLite3::~DBSQLite3() { sqlite3_finalize(stmt_get_blocks_z); sqlite3_finalize(stmt_get_block_pos); if (sqlite3_close(db) != SQLITE_OK) { std::cerr << "Error closing SQLite database." << std::endl; }; } std::vector DBSQLite3::getBlockPos() { int result; std::vector positions; while ((result = sqlite3_step(stmt_get_block_pos)) != SQLITE_DONE) { if (result == SQLITE_ROW) { int64_t posHash = sqlite3_column_int64(stmt_get_block_pos, 0); positions.push_back(decodeBlockPos(posHash)); } else if (result == SQLITE_BUSY) { // Wait some time and try again usleep(10000); } else { throw std::runtime_error(sqlite3_errmsg(db)); } } SQLOK(reset(stmt_get_block_pos)); return positions; } void DBSQLite3::getBlocksOnZ(std::map &blocks, int16_t zPos) { int result; // Magic numbers! int64_t minPos = encodeBlockPos(BlockPos(0, -2048, zPos)); int64_t maxPos = encodeBlockPos(BlockPos(0, 2048, zPos)) - 1; SQLOK(bind_int64(stmt_get_blocks_z, 1, minPos)); SQLOK(bind_int64(stmt_get_blocks_z, 2, maxPos)); while ((result = sqlite3_step(stmt_get_blocks_z)) != SQLITE_DONE) { if (result == SQLITE_ROW) { int64_t posHash = sqlite3_column_int64(stmt_get_blocks_z, 0); const unsigned char *data = reinterpret_cast( sqlite3_column_blob(stmt_get_blocks_z, 1)); size_t size = sqlite3_column_bytes(stmt_get_blocks_z, 1); Block b(decodeBlockPos(posHash), ustring(data, size)); blocks[b.first.x].push_back(b); } else if (result == SQLITE_BUSY) { // Wait some time and try again usleep(10000); } else { throw std::runtime_error(sqlite3_errmsg(db)); } } SQLOK(reset(stmt_get_blocks_z)); } #undef SQLRES #undef SQLOK minetestmapper-20191011/include/000077500000000000000000000000001355015577700164515ustar00rootroot00000000000000minetestmapper-20191011/include/BlockDecoder.h000066400000000000000000000011761355015577700211470ustar00rootroot00000000000000#ifndef BLOCKDECODER_H #define BLOCKDECODER_H #if __cplusplus >= 201103L #include #else #include #endif #include "types.h" class BlockDecoder { public: BlockDecoder(); void reset(); void decode(const ustring &data); bool isEmpty() const; std::string getNode(u8 x, u8 y, u8 z) const; // returns "" for air, ignore and invalid nodes private: #if __cplusplus >= 201103L typedef std::unordered_map NameMap; #else typedef std::map NameMap; #endif NameMap m_nameMap; int m_blockAirId; int m_blockIgnoreId; u8 m_version; ustring m_mapData; }; #endif // BLOCKDECODER_H minetestmapper-20191011/include/Image.h000066400000000000000000000015741355015577700176530ustar00rootroot00000000000000#ifndef IMAGE_HEADER #define IMAGE_HEADER #include "types.h" #include #include struct Color { Color() : r(0), g(0), b(0), a(0) {}; Color(u8 r, u8 g, u8 b) : r(r), g(g), b(b), a(255) {}; Color(u8 r, u8 g, u8 b, u8 a) : r(r), g(g), b(b), a(a) {}; inline Color noAlpha() const { return Color(r, g, b); } u8 r, g, b, a; }; class Image { public: Image(int width, int height); ~Image(); void setPixel(int x, int y, const Color &c); Color getPixel(int x, int y); void drawLine(int x1, int y1, int x2, int y2, const Color &c); void drawText(int x, int y, const std::string &s, const Color &c); void drawFilledRect(int x, int y, int w, int h, const Color &c); void drawCircle(int x, int y, int diameter, const Color &c); void save(const std::string &filename); private: Image(const Image&); int m_width, m_height; gdImagePtr m_image; }; #endif // IMAGE_HEADER minetestmapper-20191011/include/PixelAttributes.h000066400000000000000000000022271355015577700217550ustar00rootroot00000000000000/* * ===================================================================== * Version: 1.0 * Created: 25.08.2012 10:55:29 * Author: Miroslav Bendík * Company: LinuxOS.sk * ===================================================================== */ #ifndef PIXELATTRIBUTES_H_ADZ35GYF #define PIXELATTRIBUTES_H_ADZ35GYF #include #include #include "config.h" struct PixelAttribute { PixelAttribute(): height(std::numeric_limits::min()), thickness(0) {}; int height; uint8_t thickness; inline bool valid_height() { return height != std::numeric_limits::min(); } }; class PixelAttributes { public: PixelAttributes(); virtual ~PixelAttributes(); void setWidth(int width); void scroll(); inline PixelAttribute &attribute(int z, int x) { return m_pixelAttributes[z + 1][x + 1]; }; private: void freeAttributes(); private: enum Line { FirstLine = 0, LastLine = BLOCK_SIZE, EmptyLine = BLOCK_SIZE + 1, LineCount = BLOCK_SIZE + 2 }; PixelAttribute *m_pixelAttributes[BLOCK_SIZE + 2]; // 1px gradient + empty int m_width; }; #endif /* end of include guard: PIXELATTRIBUTES_H_ADZ35GYF */ minetestmapper-20191011/include/PlayerAttributes.h000066400000000000000000000010221355015577700221200ustar00rootroot00000000000000#ifndef PLAYERATTRIBUTES_H_D7THWFVV #define PLAYERATTRIBUTES_H_D7THWFVV #include #include struct Player { std::string name; double x, y, z; }; class PlayerAttributes { public: typedef std::list Players; PlayerAttributes(const std::string &worldDir); Players::iterator begin(); Players::iterator end(); private: void readFiles(const std::string &playersPath); void readSqlite(const std::string &db_name); Players m_players; }; #endif /* end of include guard: PLAYERATTRIBUTES_H_D7THWFVV */ minetestmapper-20191011/include/TileGenerator.h000066400000000000000000000072771355015577700214030ustar00rootroot00000000000000#ifndef TILEGENERATOR_HEADER #define TILEGENERATOR_HEADER #include #include #include #if __cplusplus >= 201103L #include #include #else #include #include #endif #include #include #include "PixelAttributes.h" #include "BlockDecoder.h" #include "Image.h" #include "db.h" #include "types.h" enum { SCALE_TOP = (1 << 0), SCALE_BOTTOM = (1 << 1), SCALE_LEFT = (1 << 2), SCALE_RIGHT = (1 << 3), }; struct ColorEntry { ColorEntry(): r(0), g(0), b(0), a(0), t(0) {}; ColorEntry(uint8_t r, uint8_t g, uint8_t b, uint8_t a, uint8_t t): r(r), g(g), b(b), a(a), t(t) {}; inline Color to_color() const { return Color(r, g, b, a); } uint8_t r, g, b, a, t; }; struct BitmapThing { // 16x16 bitmap inline void reset() { for (int i = 0; i < 16; ++i) val[i] = 0; } inline bool full() const { for (int i = 0; i < 16; ++i) { if (val[i] != 0xffff) return false; } return true; } inline void set(unsigned int x, unsigned int z) { val[z] |= (1 << x); } inline bool get(unsigned int x, unsigned int z) { return !!(val[z] & (1 << x)); } uint16_t val[16]; }; class TileGenerator { private: #if __cplusplus >= 201103L typedef std::unordered_map ColorMap; typedef std::unordered_set NameSet; #else typedef std::map ColorMap; typedef std::set NameSet; #endif public: TileGenerator(); ~TileGenerator(); void setBgColor(const std::string &bgColor); void setScaleColor(const std::string &scaleColor); void setOriginColor(const std::string &originColor); void setPlayerColor(const std::string &playerColor); Color parseColor(const std::string &color); void setDrawOrigin(bool drawOrigin); void setDrawPlayers(bool drawPlayers); void setDrawScale(bool drawScale); void setDrawAlpha(bool drawAlpha); void setShading(bool shading); void setGeometry(int x, int y, int w, int h); void setMinY(int y); void setMaxY(int y); void parseColorsFile(const std::string &fileName); void setBackend(std::string backend); void generate(const std::string &input, const std::string &output); void printGeometry(const std::string &input); void setZoom(int zoom); void setScales(uint flags); void setDontWriteEmpty(bool f); private: void parseColorsStream(std::istream &in); void openDb(const std::string &input); void closeDatabase(); void loadBlocks(); void createImage(); void renderMap(); std::list getZValueList() const; void renderMapBlock(const BlockDecoder &blk, const BlockPos &pos); void renderMapBlockBottom(const BlockPos &pos); void renderShading(int zPos); void renderScale(); void renderOrigin(); void renderPlayers(const std::string &inputPath); void writeImage(const std::string &output); void printUnknown(); int getImageX(int val, bool absolute=false) const; int getImageY(int val, bool absolute=false) const; void setZoomed(int x, int y, Color color); private: Color m_bgColor; Color m_scaleColor; Color m_originColor; Color m_playerColor; bool m_drawOrigin; bool m_drawPlayers; bool m_drawScale; bool m_drawAlpha; bool m_shading; bool m_dontWriteEmpty; std::string m_backend; int m_xBorder, m_yBorder; DB *m_db; Image *m_image; PixelAttributes m_blockPixelAttributes; int m_xMin; int m_xMax; int m_zMin; int m_zMax; int m_yMin; int m_yMax; int m_geomX; int m_geomY; int m_geomX2; int m_geomY2; int m_mapWidth; int m_mapHeight; std::list > m_positions; ColorMap m_colorMap; BitmapThing m_readPixels; BitmapThing m_readInfo; NameSet m_unknownNodes; Color m_color[16][16]; uint8_t m_thickness[16][16]; int m_zoom; uint m_scales; }; // class TileGenerator #endif // TILEGENERATOR_HEADER minetestmapper-20191011/include/ZlibDecompressor.h000066400000000000000000000015351355015577700221140ustar00rootroot00000000000000/* * ===================================================================== * Version: 1.0 * Created: 18.09.2012 10:20:51 * Author: Miroslav Bendík * Company: LinuxOS.sk * ===================================================================== */ #ifndef ZLIBDECOMPRESSOR_H_ZQL1PN8Q #define ZLIBDECOMPRESSOR_H_ZQL1PN8Q #include #include #include "types.h" class ZlibDecompressor { public: class DecompressError { }; ZlibDecompressor(const unsigned char *data, std::size_t size); ~ZlibDecompressor(); void setSeekPos(std::size_t seekPos); std::size_t seekPos() const; ustring decompress(); private: const unsigned char *m_data; std::size_t m_seekPos; std::size_t m_size; }; /* ----- end of class ZlibDecompressor ----- */ #endif /* end of include guard: ZLIBDECOMPRESSOR_H_ZQL1PN8Q */ minetestmapper-20191011/include/cmake_config.h.in000066400000000000000000000003411355015577700216320ustar00rootroot00000000000000// Filled in by the build system #ifndef CMAKE_CONFIG_H #define CMAKE_CONFIG_H #define USE_POSTGRESQL @USE_POSTGRESQL@ #define USE_LEVELDB @USE_LEVELDB@ #define USE_REDIS @USE_REDIS@ #define SHAREDIR "@SHAREDIR@" #endif minetestmapper-20191011/include/config.h000066400000000000000000000004611355015577700200700ustar00rootroot00000000000000#if MSDOS || __OS2__ || __NT__ || _WIN32 #define PATH_SEPARATOR '\\' #else #define PATH_SEPARATOR '/' #endif #define BLOCK_SIZE 16 #ifdef USE_CMAKE_CONFIG_H #include "cmake_config.h" #else #define USE_POSTGRESQL 0 #define USE_LEVELDB 0 #define USE_REDIS 0 #define SHAREDIR "/usr/share/minetest" #endif minetestmapper-20191011/include/db-leveldb.h000066400000000000000000000006641355015577700206300ustar00rootroot00000000000000#ifndef DB_LEVELDB_HEADER #define DB_LEVELDB_HEADER #include "db.h" #include class DBLevelDB : public DB { public: DBLevelDB(const std::string &mapdir); virtual std::vector getBlockPos(); virtual void getBlocksOnZ(std::map &blocks, int16_t zPos); virtual ~DBLevelDB(); private: void loadPosCache(); std::vector posCache; leveldb::DB *db; }; #endif // DB_LEVELDB_HEADER minetestmapper-20191011/include/db-postgresql.h000066400000000000000000000015771355015577700214220ustar00rootroot00000000000000#ifndef _DB_POSTGRESQL_H #define _DB_POSTGRESQL_H #include "db.h" #include class DBPostgreSQL : public DB { public: DBPostgreSQL(const std::string &mapdir); virtual std::vector getBlockPos(); virtual void getBlocksOnZ(std::map &blocks, int16_t zPos); virtual ~DBPostgreSQL(); protected: PGresult *checkResults(PGresult *res, bool clear = true); void prepareStatement(const std::string &name, const std::string &sql); PGresult *execPrepared( const char *stmtName, const int paramsNumber, const void **params, const int *paramsLengths = NULL, const int *paramsFormats = NULL, bool clear = true, bool nobinary = true ); int pg_to_int(PGresult *res, int row, int col); int pg_binary_to_int(PGresult *res, int row, int col); BlockPos pg_to_blockpos(PGresult *res, int row, int col); private: PGconn *db; }; #endif // _DB_POSTGRESQL_H minetestmapper-20191011/include/db-redis.h000066400000000000000000000010721355015577700203130ustar00rootroot00000000000000#ifndef DB_REDIS_HEADER #define DB_REDIS_HEADER #include "db.h" #include class DBRedis : public DB { public: DBRedis(const std::string &mapdir); virtual std::vector getBlockPos(); virtual void getBlocksOnZ(std::map &blocks, int16_t zPos); virtual ~DBRedis(); private: static std::string replyTypeStr(int type); void loadPosCache(); void HMGET(const std::vector &positions, std::vector *result); std::vector posCache; redisContext *ctx; std::string hash; }; #endif // DB_REDIS_HEADER minetestmapper-20191011/include/db-sqlite3.h000066400000000000000000000006561355015577700206000ustar00rootroot00000000000000#ifndef _DB_SQLITE3_H #define _DB_SQLITE3_H #include "db.h" #include class DBSQLite3 : public DB { public: DBSQLite3(const std::string &mapdir); virtual std::vector getBlockPos(); virtual void getBlocksOnZ(std::map &blocks, int16_t zPos); virtual ~DBSQLite3(); private: sqlite3 *db; sqlite3_stmt *stmt_get_block_pos; sqlite3_stmt *stmt_get_blocks_z; }; #endif // _DB_SQLITE3_H minetestmapper-20191011/include/db.h000066400000000000000000000040051355015577700172060ustar00rootroot00000000000000#ifndef DB_HEADER #define DB_HEADER #include #include #include #include #include #include #include "types.h" class BlockPos { public: int16_t x; int16_t y; int16_t z; BlockPos() : x(0), y(0), z(0) {} BlockPos(int16_t x, int16_t y, int16_t z) : x(x), y(y), z(z) {} bool operator < (const BlockPos &p) const { if (z > p.z) return true; if (z < p.z) return false; if (y > p.y) return true; if (y < p.y) return false; if (x > p.x) return true; if (x < p.x) return false; return false; } }; typedef std::pair Block; typedef std::list BlockList; class DB { protected: inline int64_t encodeBlockPos(const BlockPos pos) const; inline BlockPos decodeBlockPos(int64_t hash) const; public: virtual std::vector getBlockPos() = 0; virtual void getBlocksOnZ(std::map &blocks, int16_t zPos) = 0; virtual ~DB() {}; }; /**************** * Black magic! * **************** * The position hashing is seriously messed up, * and is a lot more complicated than it looks. */ static inline int16_t unsigned_to_signed(uint16_t i, uint16_t max_positive) { if (i < max_positive) { return i; } else { return i - (max_positive * 2); } } // Modulo of a negative number does not work consistently in C static inline int64_t pythonmodulo(int64_t i, int64_t mod) { if (i >= 0) { return i % mod; } return mod - ((-i) % mod); } inline int64_t DB::encodeBlockPos(const BlockPos pos) const { return (uint64_t) pos.z * 0x1000000 + (uint64_t) pos.y * 0x1000 + (uint64_t) pos.x; } inline BlockPos DB::decodeBlockPos(int64_t hash) const { BlockPos pos; pos.x = unsigned_to_signed(pythonmodulo(hash, 4096), 2048); hash = (hash - pos.x) / 4096; pos.y = unsigned_to_signed(pythonmodulo(hash, 4096), 2048); hash = (hash - pos.y) / 4096; pos.z = unsigned_to_signed(pythonmodulo(hash, 4096), 2048); return pos; } /******************* * End black magic * *******************/ #endif // DB_HEADER minetestmapper-20191011/include/types.h000066400000000000000000000001721355015577700177660ustar00rootroot00000000000000#include typedef std::basic_string ustring; typedef unsigned int uint; typedef unsigned char u8; minetestmapper-20191011/include/util.h000066400000000000000000000005471355015577700176050ustar00rootroot00000000000000#ifndef UTIL_H #define UTIL_H #include #include std::string read_setting(const std::string &name, std::istream &is); inline std::string read_setting_default(const std::string &name, std::istream &is, const std::string &def) { try { return read_setting(name, is); } catch(std::runtime_error &e) { return def; } } #endif // UTIL_H minetestmapper-20191011/mapper.cpp000066400000000000000000000120401355015577700170130ustar00rootroot00000000000000#include #include #include #include #include #include #include #include #include #include "cmake_config.h" #include "TileGenerator.h" void usage() { const char *usage_text = "minetestmapper [options]\n" " -i/--input \n" " -o/--output \n" " --bgcolor \n" " --scalecolor \n" " --playercolor \n" " --origincolor \n" " --drawscale\n" " --drawplayers\n" " --draworigin\n" " --drawalpha\n" " --noshading\n" " --noemptyimage\n" " --min-y \n" " --max-y \n" " --backend \n" " --geometry x:y+w+h\n" " --extent\n" " --zoom \n" " --colors \n" " --scales [t][b][l][r]\n" "Color format: '#000000'\n"; std::cout << usage_text; } bool file_exists(const std::string &path) { std::ifstream ifs(path.c_str()); return ifs.is_open(); } std::string search_colors(const std::string &worldpath) { if(file_exists(worldpath + "/colors.txt")) return worldpath + "/colors.txt"; #ifndef _WIN32 char *home = std::getenv("HOME"); if(home) { std::string check = ((std::string) home) + "/.minetest/colors.txt"; if(file_exists(check)) return check; } #endif if(!(SHAREDIR[0] == '.' || SHAREDIR[0] == '\0') && file_exists(SHAREDIR "/colors.txt")) return SHAREDIR "/colors.txt"; std::cerr << "Warning: Falling back to using colors.txt from current directory." << std::endl; return "colors.txt"; } int main(int argc, char *argv[]) { static struct option long_options[] = { {"help", no_argument, 0, 'h'}, {"input", required_argument, 0, 'i'}, {"output", required_argument, 0, 'o'}, {"bgcolor", required_argument, 0, 'b'}, {"scalecolor", required_argument, 0, 's'}, {"origincolor", required_argument, 0, 'r'}, {"playercolor", required_argument, 0, 'p'}, {"draworigin", no_argument, 0, 'R'}, {"drawplayers", no_argument, 0, 'P'}, {"drawscale", no_argument, 0, 'S'}, {"drawalpha", no_argument, 0, 'e'}, {"noshading", no_argument, 0, 'H'}, {"backend", required_argument, 0, 'd'}, {"geometry", required_argument, 0, 'g'}, {"extent", no_argument, 0, 'E'}, {"min-y", required_argument, 0, 'a'}, {"max-y", required_argument, 0, 'c'}, {"zoom", required_argument, 0, 'z'}, {"colors", required_argument, 0, 'C'}, {"scales", required_argument, 0, 'f'}, {"noemptyimage", no_argument, 0, 'n'}, {0, 0, 0, 0} }; std::string input; std::string output; std::string colors = ""; TileGenerator generator; bool onlyPrintExtent = false; while (1) { int option_index; int c = getopt_long(argc, argv, "hi:o:", long_options, &option_index); if (c == -1) break; // done switch (c) { case 'h': usage(); return 0; break; case 'i': input = optarg; break; case 'o': output = optarg; break; case 'b': generator.setBgColor(optarg); break; case 's': generator.setScaleColor(optarg); break; case 'r': generator.setOriginColor(optarg); break; case 'p': generator.setPlayerColor(optarg); break; case 'R': generator.setDrawOrigin(true); break; case 'P': generator.setDrawPlayers(true); break; case 'S': generator.setDrawScale(true); break; case 'e': generator.setDrawAlpha(true); break; case 'E': onlyPrintExtent = true; break; case 'H': generator.setShading(false); break; case 'd': generator.setBackend(optarg); break; case 'a': { std::istringstream iss(optarg); int miny; iss >> miny; generator.setMinY(miny); } break; case 'c': { std::istringstream iss(optarg); int maxy; iss >> maxy; generator.setMaxY(maxy); } break; case 'g': { std::istringstream geometry(optarg); int x, y, w, h; char c; geometry >> x >> c >> y >> w >> h; if (geometry.fail() || c != ':' || w < 1 || h < 1) { usage(); exit(1); } generator.setGeometry(x, y, w, h); } break; case 'f': { uint flags = 0; if(strchr(optarg, 't') != NULL) flags |= SCALE_TOP; if(strchr(optarg, 'b') != NULL) flags |= SCALE_BOTTOM; if(strchr(optarg, 'l') != NULL) flags |= SCALE_LEFT; if(strchr(optarg, 'r') != NULL) flags |= SCALE_RIGHT; generator.setScales(flags); } break; case 'z': { std::istringstream iss(optarg); int zoom; iss >> zoom; generator.setZoom(zoom); } break; case 'C': colors = optarg; break; case 'n': generator.setDontWriteEmpty(true); break; default: exit(1); } } if (input.empty() || (!onlyPrintExtent && output.empty())) { usage(); return 0; } try { if (onlyPrintExtent) { generator.printGeometry(input); return 0; } if(colors == "") colors = search_colors(input); generator.parseColorsFile(colors); generator.generate(input, output); } catch(std::runtime_error &e) { std::cerr << "Exception: " << e.what() << std::endl; return 1; } return 0; } minetestmapper-20191011/minetestmapper.6000066400000000000000000000047061355015577700201610ustar00rootroot00000000000000.TH MINETESTMAPPER 6 .SH NAME minetestmapper \- generate an overview image of a Minetest map .SH SYNOPSIS .B minetestmapper \fB\-i\fR \fIworld_path\fR \fB\-o\fR \fIoutput_image\fR .PP See additional optional parameters below. .SH DESCRIPTION .B minetestmapper generates an overview image of a minetest map. This is a port of the original minetestmapper.py to C++, that is both faster and provides more functionality than the deprecated Python script. .SH MANDATORY PARAMETERS .TP .BR \-i " " \fIworld_path\fR Input world path. .TP .BR \-o " " \fIoutput_image\fR Path to output image. (only PNG supported currently) .SH OPTIONAL PARAMETERS .TP .BR \-\-bgcolor " " \fIcolor\fR Background color of image, e.g. "--bgcolor #ffffff" .TP .BR \-\-scalecolor " " \fIcolor\fR Color of scale, e.g. "--scalecolor #000000" .TP .BR \-\-playercolor " " \fIcolor\fR Color of player indicators, e.g. "--playercolor #ff0000" .TP .BR \-\-origincolor " " \fIcolor\fR Color of origin indicator, e.g. "--origincolor #ff0000" .TP .BR \-\-drawscale Draw tick marks .TP .BR \-\-drawplayers Draw player indicators .TP .BR \-\-draworigin Draw origin indicator .TP .BR \-\-drawalpha Allow nodes to be drawn with transparency .TP .BR \-\-noshading Don't draw shading on nodes .TP .BR \-\-noemptyimage Don't output anything when the image would be empty. .TP .BR \-\-min-y " " \fInumber\fR Don't draw nodes below this y value, e.g. "--min-y -25" .TP .BR \-\-max-y " " \fInumber\fR Don't draw nodes above this y value, e.g. "--max-y 75" .TP .BR \-\-backend " " \fIbackend\fR Use specific map backend; supported: *sqlite3*, *leveldb*, *redis*, *postgresql*, e.g. "--backend leveldb" .TP .BR \-\-geometry " " \fIgeometry\fR Limit area to specific geometry (*x:y+w+h* where x and y specify the lower left corner), e.g. "--geometry -800:-800+1600+1600" .TP .BR \-\-extent " " \fIextent\fR Dont render the image, just print the extent of the map that would be generated, in the same format as the geometry above. .TP .BR \-\-zoom " " \fIfactor\fR Zoom the image by using more than one pixel per node, e.g. "--zoom 4" .TP .BR \-\-colors " " \fIpath\fR Forcefully set path to colors.txt file (it's autodetected otherwise), e.g. "--colors ../minetest/mycolors.txt" .TP .BR \-\-scales " " \fIedges\fR Draw scales on specified image edges (letters *t b l r* meaning top, bottom, left and right), e.g. "--scales tbr" .SH MORE INFORMATION Website: https://github.com/minetest/minetestmapper .SH MAN PAGE AUTHOR Daniel Moerner minetestmapper-20191011/util.cpp000066400000000000000000000024221355015577700165070ustar00rootroot00000000000000#include #include #include "util.h" inline std::string trim(const std::string &s) { size_t front = 0; while(s[front] == ' ' || s[front] == '\t' || s[front] == '\r' || s[front] == '\n' ) ++front; size_t back = s.size(); while(back > front && (s[back-1] == ' ' || s[back-1] == '\t' || s[back-1] == '\r' || s[back-1] == '\n' ) ) --back; return s.substr(front, back - front); } #define EOFCHECK() do { \ if (is.eof()) { \ std::ostringstream oss; \ oss << "Setting '" << name << "' not found."; \ throw std::runtime_error(oss.str()); \ } \ } while(0) std::string read_setting(const std::string &name, std::istream &is) { char c; char s[256]; std::string nm, value; next: while((c = is.get()) == ' ' || c == '\t' || c == '\r' || c == '\n') ; EOFCHECK(); if(c == '#') // Ignore comments is.ignore(0xffff, '\n'); EOFCHECK(); s[0] = c; // The current char belongs to the name too is.get(&s[1], 255, '='); is.ignore(1); // Jump over the = EOFCHECK(); nm = trim(std::string(s)); is.get(s, 256, '\n'); value = trim(std::string(s)); if(name == nm) return value; else goto next; } #undef EOFCHECK minetestmapper-20191011/util/000077500000000000000000000000001355015577700160035ustar00rootroot00000000000000minetestmapper-20191011/util/build_win.sh000077500000000000000000000027651355015577700203300ustar00rootroot00000000000000#!/bin/bash -e ####### # this expects an env similar to what minetest's buildbot uses # extradll_path will typically contain libgcc, libstdc++ and libpng toolchain_file= toolchain_file64= libgd_dir= libgd_dir64= zlib_dir= zlib_dir64= sqlite_dir= sqlite_dir64= leveldb_dir= leveldb_dir64= extradll_path= extradll_path64= ####### [ -f ./CMakeLists.txt ] || exit 1 if [ "$1" == "32" ]; then : elif [ "$1" == "64" ]; then toolchain_file=$toolchain_file64 libgd_dir=$libgd_dir64 zlib_dir=$zlib_dir64 sqlite_dir=$sqlite_dir64 leveldb_dir=$leveldb_dir64 extradll_path=$extradll_path64 else echo "Usage: $0 <32 / 64>" exit 1 fi cmake . \ -DCMAKE_INSTALL_PREFIX=/tmp \ -DCMAKE_TOOLCHAIN_FILE=$toolchain_file \ -DCMAKE_EXE_LINKER_FLAGS="-s" \ \ -DENABLE_LEVELDB=1 \ \ -DLIBGD_INCLUDE_DIR=$libgd_dir/include \ -DLIBGD_LIBRARY=$libgd_dir/lib/libgd.dll.a \ \ -DZLIB_INCLUDE_DIR=$zlib_dir/include \ -DZLIB_LIBRARY=$zlib_dir/lib/libz.dll.a \ \ -DSQLITE3_INCLUDE_DIR=$sqlite_dir/include \ -DSQLITE3_LIBRARY=$sqlite_dir/lib/libsqlite3.dll.a \ \ -DLEVELDB_INCLUDE_DIR=$leveldb_dir/include \ -DLEVELDB_LIBRARY=$leveldb_dir/lib/libleveldb.dll.a make -j4 mkdir pack cp -p \ AUTHORS colors.txt COPYING README.rst \ minetestmapper.exe \ $libgd_dir/bin/libgd-3.dll \ $zlib_dir/bin/zlib1.dll \ $sqlite_dir/bin/libsqlite3-0.dll \ $leveldb_dir/bin/libleveldb.dll \ $extradll_path/*.dll \ pack/ zipfile=minetestmapper-win$1.zip (cd pack; zip -9r ../$zipfile *) make clean rm -r pack CMakeCache.txt echo "Done." minetestmapper-20191011/util/travis/000077500000000000000000000000001355015577700173135ustar00rootroot00000000000000minetestmapper-20191011/util/travis/script.sh000077500000000000000000000001351355015577700211550ustar00rootroot00000000000000#!/bin/bash -e mkdir -p travisbuild cd travisbuild cmake .. \ -DENABLE_LEVELDB=1 make -j2