Tune block fetching to clients on server - minetest.git - modified minetest for gpcfs purposes

diff options

author	Perttu Ahola <celeron55@gmail.com>	2012-01-27 14:12:12 +0200
committer	Perttu Ahola <celeron55@gmail.com>	2012-03-27 19:01:52 +0300
commit	6f20a7378257d09a15cce675ed7ec8363e5f3b42 (patch)
tree	003a074a45160456d977dc19ebb945666a4cb113 /games/minimal/mods/default/textures/default_cobble.png
parent	8cb7badd632200e06004577f351b9c845c174e29 (diff)
download	minetest-6f20a7378257d09a15cce675ed7ec8363e5f3b42.tar.gz minetest-6f20a7378257d09a15cce675ed7ec8363e5f3b42.tar.bz2 minetest-6f20a7378257d09a15cce675ed7ec8363e5f3b42.zip

Tune block fetching to clients on server

Diffstat (limited to 'games/minimal/mods/default/textures/default_cobble.png')

0 files changed, 0 insertions, 0 deletions

/* Minetest Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com> This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #include "test.h" #include <sstream> #include "irrlichttypes_extrabloated.h" #include "log.h" #include "serialization.h" #include "nodedef.h" #include "noise.h" class TestCompression : public TestBase { public: TestCompression() { TestManager::registerTestModule(this); } const char *getName() { return "TestCompression"; } void runTests(IGameDef *gamedef); void testRLECompression(); void testZlibCompression(); void testZlibLargeData(); }; static TestCompression g_test_instance; void TestCompression::runTests(IGameDef *gamedef) { TEST(testRLECompression); TEST(testZlibCompression); TEST(testZlibLargeData); } //////////////////////////////////////////////////////////////////////////////// void TestCompression::testRLECompression() { SharedBuffer<u8> fromdata(4); fromdata[0]=1; fromdata[1]=5; fromdata[2]=5; fromdata[3]=1; std::ostringstream os(std::ios_base::binary); compress(fromdata, os, 0); std::string str_out = os.str(); d='n351' href='#n351'>351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466

/* Minetest Copyright (C) 2017-2018 vlapsley, Vaughan Lapsley <vlapsley@gmail.com> Copyright (C) 2010-2018 paramat Copyright (C) 2010-2018 kwolekr, Ryan Kwolek <kwolekr@minetest.net> This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #include <cmath> #include "mapgen.h" #include "voxel.h" #include "noise.h" #include "mapblock.h" #include "mapnode.h" #include "map.h" #include "content_sao.h" #include "nodedef.h" #include "voxelalgorithms.h" //#include "profiler.h" // For TimeTaker #include "settings.h" // For g_settings #include "emerge.h" #include "dungeongen.h" #include "cavegen.h" #include "mg_biome.h" #include "mg_ore.h" #include "mg_decoration.h" #include "mapgen_carpathian.h" FlagDesc flagdesc_mapgen_carpathian[] = { {"caverns", MGCARPATHIAN_CAVERNS}, {NULL, 0} }; /////////////////////////////////////////////////////////////////////////////// MapgenCarpathian::MapgenCarpathian( int mapgenid, MapgenCarpathianParams *params, EmergeManager *emerge) : MapgenBasic(mapgenid, params, emerge) { base_level = params->base_level; spflags = params->spflags; cave_width = params->cave_width; large_cave_depth = params->large_cave_depth; lava_depth = params->lava_depth; cavern_limit = params->cavern_limit; cavern_taper = params->cavern_taper; cavern_threshold = params->cavern_threshold; dungeon_ymin = params->dungeon_ymin; dungeon_ymax = params->dungeon_ymax; grad_wl = 1 - water_level; //// 2D Terrain noise noise_filler_depth = new Noise(&params->np_filler_depth, seed, csize.X, csize.Z); noise_height1 = new Noise(&params->np_height1, seed, csize.X, csize.Z); noise_height2 = new Noise(&params->np_height2, seed, csize.X, csize.Z); noise_height3 = new Noise(&params->np_height3, seed, csize.X, csize.Z); noise_height4 = new Noise(&params->np_height4, seed, csize.X, csize.Z); noise_hills_terrain = new Noise(&params->np_hills_terrain, seed, csize.X, csize.Z); noise_ridge_terrain = new Noise(&params->np_ridge_terrain, seed, csize.X, csize.Z); noise_step_terrain = new Noise(&params->np_step_terrain, seed, csize.X, csize.Z); noise_hills = new Noise(&params->np_hills, seed, csize.X, csize.Z); noise_ridge_mnt = new Noise(&params->np_ridge_mnt, seed, csize.X, csize.Z); noise_step_mnt = new Noise(&params->np_step_mnt, seed, csize.X, csize.Z); //// 3D terrain noise // 1 up 1 down overgeneration noise_mnt_var = new Noise(&params->np_mnt_var, seed, csize.X, csize.Y + 2, csize.Z); //// Cave noise MapgenBasic::np_cave1 = params->np_cave1; MapgenBasic::np_cave2 = params->np_cave2; MapgenBasic::np_cavern = params->np_cavern; } MapgenCarpathian::~MapgenCarpathian() { delete noise_filler_depth; delete noise_height1; delete noise_height2; delete noise_height3; delete noise_height4; delete noise_hills_terrain; delete noise_ridge_terrain; delete noise_step_terrain; delete noise_hills; delete noise_ridge_mnt; delete noise_step_mnt; delete noise_mnt_var; } MapgenCarpathianParams::MapgenCarpathianParams(): np_filler_depth (0, 1, v3f(128, 128, 128), 261, 3, 0.7, 2.0), np_height1 (0, 5, v3f(251, 251, 251), 9613, 5, 0.5, 2.0), np_height2 (0, 5, v3f(383, 383, 383), 1949, 5, 0.5, 2.0), np_height3 (0, 5, v3f(509, 509, 509), 3211, 5, 0.5, 2.0), np_height4 (0, 5, v3f(631, 631, 631), 1583, 5, 0.5, 2.0), np_hills_terrain (1, 1, v3f(1301, 1301, 1301), 1692, 5, 0.5, 2.0), np_ridge_terrain (1, 1, v3f(1889, 1889, 1889), 3568, 5, 0.5, 2.0), np_step_terrain (1, 1, v3f(1889, 1889, 1889), 4157, 5, 0.5, 2.0), np_hills (0, 3, v3f(257, 257, 257), 6604, 6, 0.5, 2.0), np_ridge_mnt (0, 12, v3f(743, 743, 743), 5520, 6, 0.7, 2.0), np_step_mnt (0, 8, v3f(509, 509, 509), 2590, 6, 0.6, 2.0), np_mnt_var (0, 1, v3f(499, 499, 499), 2490, 5, 0.55, 2.0), np_cave1 (0, 12, v3f(61, 61, 61), 52534, 3, 0.5, 2.0), np_cave2 (0, 12, v3f(67, 67, 67), 10325, 3, 0.5, 2.0), np_cavern (0, 1, v3f(384, 128, 384), 723, 5, 0.63, 2.0) { } void MapgenCarpathianParams::readParams(const Settings *settings) { settings->getFlagStrNoEx("mgcarpathian_spflags", spflags, flagdesc_mapgen_carpathian); settings->getFloatNoEx("mgcarpathian_base_level", base_level); settings->getFloatNoEx("mgcarpathian_cave_width", cave_width); settings->getS16NoEx("mgcarpathian_large_cave_depth", large_cave_depth); settings->getS16NoEx("mgcarpathian_lava_depth", lava_depth); settings->getS16NoEx("mgcarpathian_cavern_limit", cavern_limit); settings->getS16NoEx("mgcarpathian_cavern_taper", cavern_taper); settings->getFloatNoEx("mgcarpathian_cavern_threshold", cavern_threshold); settings->getS16NoEx("mgcarpathian_dungeon_ymin", dungeon_ymin); settings->getS16NoEx("mgcarpathian_dungeon_ymax", dungeon_ymax); settings->getNoiseParams("mgcarpathian_np_filler_depth", np_filler_depth); settings->getNoiseParams("mgcarpathian_np_height1", np_height1); settings->getNoiseParams("mgcarpathian_np_height2", np_height2); settings->getNoiseParams("mgcarpathian_np_height3", np_height3); settings->getNoiseParams("mgcarpathian_np_height4", np_height4); settings->getNoiseParams("mgcarpathian_np_hills_terrain", np_hills_terrain); settings->getNoiseParams("mgcarpathian_np_ridge_terrain", np_ridge_terrain); settings->getNoiseParams("mgcarpathian_np_step_terrain", np_step_terrain); settings->getNoiseParams("mgcarpathian_np_hills", np_hills); settings->getNoiseParams("mgcarpathian_np_ridge_mnt", np_ridge_mnt); settings->getNoiseParams("mgcarpathian_np_step_mnt", np_step_mnt); settings->getNoiseParams("mgcarpathian_np_mnt_var", np_mnt_var); settings->getNoiseParams("mgcarpathian_np_cave1", np_cave1); settings->getNoiseParams("mgcarpathian_np_cave2", np_cave2); settings->getNoiseParams("mgcarpathian_np_cavern", np_cavern); } void MapgenCarpathianParams::writeParams(Settings *settings) const { settings->setFlagStr("mgcarpathian_spflags", spflags, flagdesc_mapgen_carpathian, U32_MAX); settings->setFloat("mgcarpathian_base_level", base_level); settings->setFloat("mgcarpathian_cave_width", cave_width); settings->setS16("mgcarpathian_large_cave_depth", large_cave_depth); settings->setS16("mgcarpathian_lava_depth", lava_depth); settings->setS16("mgcarpathian_cavern_limit", cavern_limit); settings->setS16("mgcarpathian_cavern_taper", cavern_taper); settings->setFloat("mgcarpathian_cavern_threshold", cavern_threshold); settings->setS16("mgcarpathian_dungeon_ymin", dungeon_ymin); settings->setS16("mgcarpathian_dungeon_ymax", dungeon_ymax); settings->setNoiseParams("mgcarpathian_np_filler_depth", np_filler_depth); settings->setNoiseParams("mgcarpathian_np_height1", np_height1); settings->setNoiseParams("mgcarpathian_np_height2", np_height2); settings->setNoiseParams("mgcarpathian_np_height3", np_height3); settings->setNoiseParams("mgcarpathian_np_height4", np_height4); settings->setNoiseParams("mgcarpathian_np_hills_terrain", np_hills_terrain); settings->setNoiseParams("mgcarpathian_np_ridge_terrain", np_ridge_terrain); settings->setNoiseParams("mgcarpathian_np_step_terrain", np_step_terrain); settings->setNoiseParams("mgcarpathian_np_hills", np_hills); settings->setNoiseParams("mgcarpathian_np_ridge_mnt", np_ridge_mnt); settings->setNoiseParams("mgcarpathian_np_step_mnt", np_step_mnt); settings->setNoiseParams("mgcarpathian_np_mnt_var", np_mnt_var); settings->setNoiseParams("mgcarpathian_np_cave1", np_cave1); settings->setNoiseParams("mgcarpathian_np_cave2", np_cave2); settings->setNoiseParams("mgcarpathian_np_cavern", np_cavern); } //////////////////////////////////////////////////////////////////////////////// // Lerp function inline float MapgenCarpathian::getLerp(float noise1, float noise2, float mod) { return noise1 + mod * (noise2 - noise1); } // Steps function float MapgenCarpathian::getSteps(float noise) { float w = 0.5f; float k = std::floor(noise / w); float f = (noise - k * w) / w; float s = std::fmin(2.f * f, 1.f); return (k + s) * w; } //////////////////////////////////////////////////////////////////////////////// void MapgenCarpathian::makeChunk(BlockMakeData *data) { // Pre-conditions assert(data->vmanip); assert(data->nodedef); assert(data->blockpos_requested.X >= data->blockpos_min.X && data->blockpos_requested.Y >= data->blockpos_min.Y && data->blockpos_requested.Z >= data->blockpos_min.Z); assert(data->blockpos_requested.X <= data->blockpos_max.X && data->blockpos_requested.Y <= data->blockpos_max.Y && data->blockpos_requested.Z <= data->blockpos_max.Z); this->generating = true; this->vm = data->vmanip; this->ndef = data->nodedef; v3s16 blockpos_min = data->blockpos_min; v3s16 blockpos_max = data->blockpos_max; node_min = blockpos_min * MAP_BLOCKSIZE; node_max = (blockpos_max + v3s16(1, 1, 1)) * MAP_BLOCKSIZE - v3s16(1, 1, 1); full_node_min = (blockpos_min - 1) * MAP_BLOCKSIZE; full_node_max = (blockpos_max + 2) * MAP_BLOCKSIZE - v3s16(1, 1, 1); // Create a block-specific seed blockseed = getBlockSeed2(full_node_min, seed); // Generate terrain s16 stone_surface_max_y = generateTerrain(); // Create heightmap updateHeightmap(node_min, node_max); // Init biome generator, place biome-specific nodes, and build biomemap biomegen->calcBiomeNoise(node_min); generateBiomes(); // Generate tunnels, caverns and large randomwalk caves if (flags & MG_CAVES) { // Generate tunnels first as caverns confuse them generateCavesNoiseIntersection(stone_surface_max_y); // Generate caverns bool near_cavern = false; if (spflags & MGCARPATHIAN_CAVERNS) near_cavern = generateCavernsNoise(stone_surface_max_y); // Generate large randomwalk caves if (near_cavern) // Disable large randomwalk caves in this mapchunk by setting // 'large cave depth' to world base. Avoids excessive liquid in // large caverns and floating blobs of overgenerated liquid. generateCavesRandomWalk(stone_surface_max_y, -MAX_MAP_GENERATION_LIMIT); else generateCavesRandomWalk(stone_surface_max_y, large_cave_depth); } // Generate dungeons if ((flags & MG_DUNGEONS) && full_node_min.Y >= dungeon_ymin && full_node_max.Y <= dungeon_ymax) generateDungeons(stone_surface_max_y); // Generate the registered decorations if (flags & MG_DECORATIONS) m_emerge->decomgr->placeAllDecos(this, blockseed, node_min, node_max); // Generate the registered ores m_emerge->oremgr->placeAllOres(this, blockseed, node_min, node_max); // Sprinkle some dust on top after everything else was generated dustTopNodes(); // Update liquids updateLiquid(&data->transforming_liquid, full_node_min, full_node_max); // Calculate lighting if (flags & MG_LIGHT) { calcLighting(node_min - v3s16(0, 1, 0), node_max + v3s16(0, 1, 0), full_node_min, full_node_max); } this->generating = false; } //////////////////////////////////////////////////////////////////////////////// int MapgenCarpathian::getSpawnLevelAtPoint(v2s16 p) { s16 level_at_point = terrainLevelAtPoint(p.X, p.Y); if (level_at_point <= water_level || level_at_point > water_level + 32) return MAX_MAP_GENERATION_LIMIT; // Unsuitable spawn point return level_at_point; } float MapgenCarpathian::terrainLevelAtPoint(s16 x, s16 z) {


context:
space:
mode: