Fix search behavior - lifomapserver.git - map server for linuxforks

diff options

author	Markus Koch <markus@notsyncing.net>	2020-04-25 17:34:33 +0200
committer	Markus Koch <markus@notsyncing.net>	2020-04-25 17:34:33 +0200
commit	5b5ce97a1a0a8e2bac0b875baddcd59fd8b54b67 (patch)
tree	e0fa4a302bedfc20a319d7c017ce1509a6bd299e
parent	d229044ebfaf0a2d09d002c4c490de2d9248dcfd (diff)
download	lifomapserver-5b5ce97a1a0a8e2bac0b875baddcd59fd8b54b67.tar.gz lifomapserver-5b5ce97a1a0a8e2bac0b875baddcd59fd8b54b67.tar.bz2 lifomapserver-5b5ce97a1a0a8e2bac0b875baddcd59fd8b54b67.zip

Fix search behavior

Before, it was always searching for the current term without the last entered (or with the last deleted) character. This behavior is fixed now. Also, an empty query will now match (hopefully) nothing instead of everything.

Diffstat

-rw-r--r--

htdocs/mapscript.js

1 files changed, 5 insertions, 3 deletions

/* Minetest Valleys C Copyright (C) 2010-2015 kwolekr, Ryan Kwolek <kwolekr@minetest.net> Copyright (C) 2010-2015 paramat, Matt Gregory Copyright (C) 2016 Duane Robertson <duane@duanerobertson.com> Based on Valleys Mapgen by Gael de Sailly (https://forum.minetest.net/viewtopic.php?f=9&t=11430) and mapgen_v7, mapgen_flat by kwolekr and paramat. Licensing changed by permission of Gael de Sailly. 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 "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 "settings.h" // For g_settings #include "emerge.h" #include "dungeongen.h" #include "treegen.h" #include "mg_biome.h" #include "mg_ore.h" #include "mg_decoration.h" #include "mapgen_valleys.h" #include "cavegen.h" //#undef NDEBUG //#include "assert.h" //#include "util/timetaker.h" //#include "profiler.h" //static Profiler mapgen_prof; //Profiler *mapgen_profiler = &mapgen_prof; static FlagDesc flagdesc_mapgen_valleys[] = { {"altitude_chill", MGVALLEYS_ALT_CHILL}, {"humid_rivers", MGVALLEYS_HUMID_RIVERS}, {NULL, 0} }; /////////////////////////////////////////////////////////////////////////////// MapgenValleys::MapgenValleys(int mapgenid, MapgenParams *params, EmergeManager *emerge) : Mapgen(mapgenid, params, emerge) { this->m_emerge = emerge; this->bmgr = emerge->biomemgr; //// amount of elements to skip for the next index //// for noise/height/biome maps (not vmanip) this->ystride = csize.X; this->zstride = csize.X * (csize.Y + 2); // 1-down overgeneration this->zstride_1d = csize.X * (csize.Y + 1); this->biomemap = new u8[csize.X * csize.Z]; this->heightmap = new s16[csize.X * csize.Z]; this->heatmap = NULL; this->humidmap = NULL; this->map_gen_limit = MYMIN(MAX_MAP_GENERATION_LIMIT, g_settings->getU16("map_generation_limit")); MapgenValleysParams *sp = (MapgenValleysParams *)params->sparams; this->spflags = sp->spflags; this->altitude_chill = sp->altitude_chill; this->large_cave_depth = sp->large_cave_depth; this->lava_features_lim = rangelim(sp->lava_features, 0, 10); this->massive_cave_depth = sp->massive_cave_depth; this->river_depth_bed = sp->river_depth + 1.f; this->river_size_factor = sp->river_size / 100.f; this->water_features_lim = rangelim(sp->water_features, 0, 10); this->cave_width = sp->cave_width; //// 2D Terrain noise noise_filler_depth = new Noise(&sp->np_filler_depth, seed, csize.X, csize.Z); noise_inter_valley_slope = new Noise(&sp->np_inter_valley_slope, seed, csize.X, csize.Z); noise_rivers = new Noise(&sp->np_rivers, seed, csize.X, csize.Z); noise_terrain_height = new Noise(&sp->np_terrain_height, seed, csize.X, csize.Z); noise_valley_depth = new Noise(&sp->np_valley_depth, seed, csize.X, csize.Z); noise_valley_profile = new Noise(&sp->np_valley_profile, seed, csize.X, csize.Z); //// 3D Terrain noise // 1-up 1-down overgeneration noise_inter_valley_fill = new Noise(&sp->np_inter_valley_fill, seed, csize.X, csize.Y + 2, csize.Z); // 1-down overgeneraion noise_cave1 = new Noise(&sp->np_cave1, seed, csize.X, csize.Y + 1, csize.Z); noise_cave2 = new Noise(&sp->np_cave2, seed, csize.X, csize.Y + 1, csize.Z); noise_massive_caves = new Noise(&sp->np_massive_caves, seed, csize.X, csize.Y + 1, csize.Z); //// Biome noise noise_heat_blend = new Noise(&params->np_biome_heat_blend, seed, csize.X, csize.Z); noise_heat = new Noise(&params->np_biome_heat, seed, csize.X, csize.Z); noise_humidity_blend = new Noise(&params->np_biome_humidity_blend, seed, csize.X, csize.Z); noise_humidity = new Noise(&params->np_biome_humidity, seed, csize.X, csize.Z); this->humid_rivers = (spflags & MGVALLEYS_HUMID_RIVERS); this->use_altitude_chill = (spflags & MGVALLEYS_ALT_CHILL); this->humidity_adjust = params->np_biome_humidity.offset - 50.f; // a small chance of overflows if the settings are very high this->cave_water_max_height = water_level + MYMAX(0, water_features_lim - 4) * 50; this->lava_max_height = water_level + MYMAX(0, lava_features_lim - 4) * 50; tcave_cache = new float[csize.Y + 2]; //// Resolve nodes to be used INodeDefManager *ndef = emerge->ndef; c_cobble = ndef->getId("mapgen_cobble"); c_desert_stone = ndef->getId("mapgen_desert_stone"); c_dirt = ndef->getId("mapgen_dirt"); c_lava_source = ndef->getId("mapgen_lava_source"); c_mossycobble = ndef->getId("mapgen_mossycobble"); c_river_water_source = ndef->getId("mapgen_river_water_source"); c_sand = ndef->getId("mapgen_sand"); c_sandstonebrick = ndef->getId("mapgen_sandstonebrick"); c_sandstone = ndef->getId("mapgen_sandstone"); c_stair_cobble = ndef->getId("mapgen_stair_cobble"); c_stair_sandstonebrick = ndef->getId("mapgen_stair_sandstonebrick"); c_stone = ndef->getId("mapgen_stone"); c_water_source = ndef->getId("mapgen_water_source"); if (c_mossycobble == CONTENT_IGNORE) c_mossycobble = c_cobble; if (c_river_water_source == CONTENT_IGNORE) c_river_water_source = c_water_source; if (c_sand == CONTENT_IGNORE) c_sand = c_stone; if (c_sandstonebrick == CONTENT_IGNORE) c_sandstonebrick = c_sandstone; if (c_stair_cobble == CONTENT_IGNORE) c_stair_cobble = c_cobble; if (c_stair_sandstonebrick == CONTENT_IGNORE) c_stair_sandstonebrick = c_sandstone; } MapgenValleys::~MapgenValleys() { delete noise_cave1; delete noise_cave2; delete noise_filler_depth; delete noise_inter_valley_fill; delete noise_inter_valley_slope; delete noise_rivers; delete noise_massive_caves; delete noise_terrain_height; delete noise_valley_depth; delete noise_valley_profile; delete noise_heat; delete noise_heat_blend; delete noise_humidity; delete noise_humidity_blend; delete[] biomemap; delete[] heightmap; delete[] tcave_cache; } MapgenValleysParams::MapgenValleysParams() { spflags = MGVALLEYS_HUMID_RIVERS | MGVALLEYS_ALT_CHILL; altitude_chill = 90; // The altitude at which temperature drops by 20C. large_cave_depth = -33; lava_features = 0; // How often water will occur in caves. massive_cave_depth = -256; // highest altitude of massive caves river_depth = 4; // How deep to carve river channels. river_size = 5; // How wide to make rivers. water_features = 0; // How often water will occur in caves. cave_width = 0.3; np_cave1 = NoiseParams(0, 12, v3f(96, 96, 96), 52534, 4, 0.5, 2.0); np_cave2 = NoiseParams(0, 12, v3f(96, 96, 96), 10325, 4, 0.5, 2.0); np_filler_depth = NoiseParams(0.f, 1.2f, v3f(256, 256, 256), 1605, 3, 0.5f, 2.f); np_inter_valley_fill = NoiseParams(0.f, 1.f, v3f(256, 512, 256), 1993, 6, 0.8f, 2.f); np_inter_valley_slope = NoiseParams(0.5f, 0.5f, v3f(128, 128, 128), 746, 1, 1.f, 2.f); np_rivers = NoiseParams(0.f, 1.f, v3f(256, 256, 256), -6050, 5, 0.6f, 2.f); np_massive_caves = NoiseParams(0.f, 1.f, v3f(768, 256, 768), 59033, 6, 0.63f, 2.f); np_terrain_height = NoiseParams(-10.f, 50.f, v3f(1024, 1024, 1024), 5202, 6, 0.4f, 2.f); np_valley_depth = NoiseParams(5.f, 4.f, v3f(512, 512, 512), -1914, 1, 1.f, 2.f); np_valley_profile = NoiseParams(0.6f, 0.5f, v3f(512, 512, 512), 777, 1, 1.f, 2.f); } void MapgenValleysParams::readParams(const Settings *settings) { settings->getFlagStrNoEx("mgvalleys_spflags", spflags, flagdesc_mapgen_valleys); settings->getU16NoEx("mgvalleys_altitude_chill", altitude_chill); settings->getS16NoEx("mgvalleys_large_cave_depth", large_cave_depth); settings->getU16NoEx("mgvalleys_lava_features", lava_features); settings->getS16NoEx("mgvalleys_massive_cave_depth", massive_cave_depth); settings->getU16NoEx("mgvalleys_river_depth", river_depth); settings->getU16NoEx("mgvalleys_river_size", river_size); settings->getU16NoEx("mgvalleys_water_features", water_features); settings->getFloatNoEx("mgvalleys_cave_width", cave_width); settings->getNoiseParams("mgvalleys_np_cave1", np_cave1); settings->getNoiseParams("mgvalleys_np_cave2", np_cave2); settings->getNoiseParams("mgvalleys_np_filler_depth", np_filler_depth); settings->getNoiseParams("mgvalleys_np_inter_valley_fill", np_inter_valley_fill); settings->getNoiseParams("mgvalleys_np_inter_valley_slope", np_inter_valley_slope); settings->getNoiseParams("mgvalleys_np_rivers", np_rivers); settings->getNoiseParams("mgvalleys_np_massive_caves", np_massive_caves); settings->getNoiseParams("mgvalleys_np_terrain_height", np_terrain_height); settings->getNoiseParams("mgvalleys_np_valley_depth", np_valley_depth); settings->getNoiseParams("mgvalleys_np_valley_profile", np_valley_profile); } void MapgenValleysParams::writeParams(Settings *settings) const { settings->setFlagStr("mgvalleys_spflags", spflags, flagdesc_mapgen_valleys, U32_MAX); settings->setU16("mgvalleys_altitude_chill", altitude_chill); settings->setS16("mgvalleys_large_cave_depth", large_cave_depth); settings->setU16("mgvalleys_lava_features", lava_features); settings->setS16("mgvalleys_massive_cave_depth", massive_cave_depth); settings->setU16("mgvalleys_river_depth", river_depth); settings->setU16("mgvalleys_river_size", river_size); settings->setU16("mgvalleys_water_features", water_features); settings->setFloat("mgvalleys_cave_width", cave_width); settings->setNoiseParams("mgvalleys_np_cave1", np_cave1); settings->setNoiseParams("mgvalleys_np_cave2", np_cave2); settings->setNoiseParams("mgvalleys_np_filler_depth", np_filler_depth); settings->setNoiseParams("mgvalleys_np_inter_valley_fill", np_inter_valley_fill); settings->setNoiseParams("mgvalleys_np_inter_valley_slope", np_inter_valley_slope); settings->setNoiseParams("mgvalleys_np_rivers", np_rivers); settings->setNoiseParams("mgvalleys_np_massive_caves", np_massive_caves); settings->setNoiseParams("mgvalleys_np_terrain_height", np_terrain_height); settings->setNoiseParams("mgvalleys_np_valley_depth", np_valley_depth); settings->setNoiseParams("mgvalleys_np_valley_profile", np_valley_profile); } /////////////////////////////////////// void MapgenValleys::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; //TimeTaker t("makeChunk"); 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); blockseed = getBlockSeed2(full_node_min, seed); // Generate noise maps and base terrain height. calculateNoise(); // Generate base terrain with initial heightmaps s16 stone_surface_max_y = generateTerrain(); // Create biomemap at heightmap surface bmgr->calcBiomes(csize.X, csize.Z, heatmap, humidmap, heightmap, biomemap); // Actually place the biome-specific nodes MgStoneType stone_type = generateBiomes(heatmap, humidmap); // Cave creation. if (flags & MG_CAVES) generateCaves(stone_surface_max_y); // Dungeon creation if ((flags & MG_DUNGEONS) && node_max.Y < 50 && (stone_surface_max_y >= node_min.Y)) { DungeonParams dp; dp.np_rarity = nparams_dungeon_rarity; dp.np_density = nparams_dungeon_density; dp.np_wetness = nparams_dungeon_wetness; dp.c_water = c_water_source; if (stone_type == STONE) { dp.c_cobble = c_cobble; dp.c_moss = c_mossycobble; dp.c_stair = c_stair_cobble; dp.diagonal_dirs = false; dp.mossratio = 3.f; dp.holesize = v3s16(1, 2, 1); dp.roomsize = v3s16(0, 0, 0); dp.notifytype = GENNOTIFY_DUNGEON; } else if (stone_type == DESERT_STONE) { dp.c_cobble = c_desert_stone; dp.c_moss = c_desert_stone; dp.c_stair = c_desert_stone; dp.diagonal_dirs = true; dp.mossratio = 0.f; dp.holesize = v3s16(2, 3, 2); dp.roomsize = v3s16(2, 5, 2); dp.notifytype = GENNOTIFY_TEMPLE; } else if (stone_type == SANDSTONE) { dp.c_cobble = c_sandstonebrick; dp.c_moss = c_sandstonebrick; dp.c_stair = c_sandstonebrick; dp.diagonal_dirs = false; dp.mossratio = 0.f; dp.holesize = v3s16(2, 2, 2); dp.roomsize = v3s16(2, 0, 2); dp.notifytype = GENNOTIFY_DUNGEON; } DungeonGen dgen(this, &dp); dgen.generate(blockseed, full_node_min, full_node_max); } // 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(); //TimeTaker tll("liquid_lighting"); updateLiquid(&data->transforming_liquid, full_node_min, full_node_max); if (flags & MG_LIGHT) calcLighting( node_min - v3s16(0, 1, 0), node_max + v3s16(0, 1, 0), full_node_min, full_node_max); //mapgen_profiler->avg("liquid_lighting", tll.stop() / 1000.f); //mapgen_profiler->avg("makeChunk", t.stop() / 1000.f); this->generating = false; } // Populate the noise tables and do most of the // calculation necessary to determine terrain height. void MapgenValleys::calculateNoise() { //TimeTaker t("calculateNoise", NULL, PRECISION_MICRO); int x = node_min.X; int y = node_min.Y - 1; int z = node_min.Z; //TimeTaker tcn("actualNoise"); noise_filler_depth->perlinMap2D(x, z); noise_heat_blend->perlinMap2D(x, z); noise_heat->perlinMap2D(x, z); noise_humidity_blend->perlinMap2D(x, z); noise_humidity->perlinMap2D(x, z); noise_inter_valley_slope->perlinMap2D(x, z); noise_rivers->perlinMap2D(x, z); noise_terrain_height->perlinMap2D(x, z); noise_valley_depth->perlinMap2D(x, z); noise_valley_profile->perlinMap2D(x, z); noise_inter_valley_fill->perlinMap3D(x, y, z); //mapgen_profiler->avg("noisemaps", tcn.stop() / 1000.f); float heat_offset = 0.f; float humidity_scale = 1.f; // Altitude chill tends to reduce the average heat. if (use_altitude_chill) heat_offset = 5.f; // River humidity tends to increase the humidity range. if (humid_rivers) { humidity_scale = 0.8f; } for (s32 index = 0; index < csize.X * csize.Z; index++) { noise_heat->result[index] += noise_heat_blend->result[index] + heat_offset; noise_humidity->result[index] *= humidity_scale; noise_humidity->result[index] += noise_humidity_blend->result[index]; } TerrainNoise tn; u32 index = 0; for (tn.z = node_min.Z; tn.z <= node_max.Z; tn.z++) for (tn.x = node_min.X; tn.x <= node_max.X; tn.x++, index++) { // The parameters that we actually need to generate terrain // are passed by address (and the return value). tn.terrain_height = noise_terrain_height->result[index]; // River noise is replaced with base terrain, which // is basically the height of the water table. tn.rivers = &noise_rivers->result[index]; // Valley depth noise is replaced with the valley // number that represents the height of terrain // over rivers and is used to determine about // how close a river is for humidity calculation. tn.valley = &noise_valley_depth->result[index]; tn.valley_profile = noise_valley_profile->result[index]; // Slope noise is replaced by the calculated slope // which is used to get terrain height in the slow // method, to create sharper mountains. tn.slope = &noise_inter_valley_slope->result[index]; tn.inter_valley_fill = noise_inter_valley_fill->result[index]; // This is the actual terrain height. float mount = terrainLevelFromNoise(&tn); noise_terrain_height->result[index] = mount; } heatmap = noise_heat->result; humidmap = noise_humidity->result; } // This keeps us from having to maintain two similar sets of // complicated code to determine ground level. float MapgenValleys::terrainLevelFromNoise(TerrainNoise *tn) { // The square function changes the behaviour of this noise: // very often small, and sometimes very high. float valley_d = MYSQUARE(*tn->valley); // valley_d is here because terrain is generally higher where valleys // are deep (mountains). base represents the height of the // rivers, most of the surface is above. float base = tn->terrain_height + valley_d; // "river" represents the distance from the river, in arbitrary units. float river = fabs(*tn->rivers) - river_size_factor; // Use the curve of the function 1-exp(-(x/a)^2) to model valleys. // Making "a" vary (0 < a <= 1) changes the shape of the valleys. // Try it with a geometry software ! // (here x = "river" and a = valley_profile). // "valley" represents the height of the terrain, from the rivers. { float t = river / tn->valley_profile; *tn->valley = valley_d * (1.f - exp(- MYSQUARE(t))); } // approximate height of the terrain at this point


context:
space:
mode: