Add some missing getter functions to the lua API - minetest.git

diff options

author	TeTpaAka <TeTpaAka@users.noreply.github.com>	2015-05-26 14:10:08 +0200
committer	est31 <MTest31@outlook.com>	2015-05-28 16:46:35 +0200
commit	c0335f7d13ee46c6a46d0ceebea96960439ec9fd (patch)
tree	20183ec9aac1dd1dfdd6f193430fb331268b92b0 /src/fontengine.h
parent	990a96578f20244626b6b9f67f8e79a7e2e614ea (diff)
download	minetest-c0335f7d13ee46c6a46d0ceebea96960439ec9fd.tar.gz minetest-c0335f7d13ee46c6a46d0ceebea96960439ec9fd.tar.bz2 minetest-c0335f7d13ee46c6a46d0ceebea96960439ec9fd.zip

Add some missing getter functions to the lua API

ObjectRef: get_properties get_armor_groups get_animation get_attach get_bone_position Players: get_physics_override hud_get_hotbar_itemcount hud_get_hotbar_image hud_get_hotbar_selected_image get_sky get_day_night_ratio get_local_animation get_eye_offset Global: minetest.get_gen_notify minetest.get_noiseparams

Diffstat (limited to 'src/fontengine.h')

0 files changed, 0 insertions, 0 deletions

/* Minetest Copyright (C) 2010-2018 celeron55, Perttu Ahola <celeron55@gmail.com> Copyright (C) 2013-2018 kwolekr, Ryan Kwolek <kwolekr@minetest.net> Copyright (C) 2015-2018 paramat 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 "gamedef.h" #include "mg_biome.h" #include "mapblock.h" #include "mapnode.h" #include "map.h" #include "nodedef.h" #include "emerge.h" #include "voxelalgorithms.h" #include "porting.h" #include "profiler.h" #include "settings.h" #include "treegen.h" #include "serialization.h" #include "util/serialize.h" #include "util/numeric.h" #include "util/directiontables.h" #include "filesys.h" #include "log.h" #include "mapgen_carpathian.h" #include "mapgen_flat.h" #include "mapgen_fractal.h" #include "mapgen_v5.h" #include "mapgen_v6.h" #include "mapgen_v7.h" #include "mapgen_valleys.h" #include "mapgen_singlenode.h" #include "cavegen.h" #include "dungeongen.h" FlagDesc flagdesc_mapgen[] = { {"caves", MG_CAVES}, {"dungeons", MG_DUNGEONS}, {"light", MG_LIGHT}, {"decorations", MG_DECORATIONS}, {"biomes", MG_BIOMES}, {NULL, 0} }; FlagDesc flagdesc_gennotify[] = { {"dungeon", 1 << GENNOTIFY_DUNGEON}, {"temple", 1 << GENNOTIFY_TEMPLE}, {"cave_begin", 1 << GENNOTIFY_CAVE_BEGIN}, {"cave_end", 1 << GENNOTIFY_CAVE_END}, {"large_cave_begin", 1 << GENNOTIFY_LARGECAVE_BEGIN}, {"large_cave_end", 1 << GENNOTIFY_LARGECAVE_END}, {"decoration", 1 << GENNOTIFY_DECORATION}, {NULL, 0} }; struct MapgenDesc { const char *name; bool is_user_visible; }; //// //// Built-in mapgens //// // Order used here defines the order of appearence in mainmenu. // v6 always last to discourage selection. // Special mapgens flat, fractal, singlenode, next to last. Of these, singlenode // last to discourage selection. // Of the remaining, v5 last due to age, v7 first due to being the default. // The order of 'enum MapgenType' in mapgen.h must match this order. static MapgenDesc g_reg_mapgens[] = { {"v7", true}, {"valleys", true}, {"carpathian", true}, {"v5", true}, {"flat", true}, {"fractal", true}, {"singlenode", true}, {"v6", true}, }; STATIC_ASSERT( ARRLEN(g_reg_mapgens) == MAPGEN_INVALID, registered_mapgens_is_wrong_size); //// //// Mapgen //// Mapgen::Mapgen(int mapgenid, MapgenParams *params, EmergeParams *emerge) : gennotify(emerge->gen_notify_on, emerge->gen_notify_on_deco_ids) { id = mapgenid; water_level = params->water_level; mapgen_limit = params->mapgen_limit; flags = params->flags; csize = v3s16(1, 1, 1) * (params->chunksize * MAP_BLOCKSIZE); /* We are losing half our entropy by doing this, but it is necessary to preserve reverse compatibility. If the top half of our current 64 bit seeds ever starts getting used, existing worlds will break due to a different hash outcome and no way to differentiate between versions. A solution could be to add a new bit to designate that the top half of the seed value should be used, essentially a 1-bit version code, but this would require increasing the total size of a seed to 9 bytes (yuck) It's probably okay if this never gets fixed. 4.2 billion possibilities ought to be enough for anyone. */ seed = (s32)params->seed; ndef = emerge->ndef; } MapgenType Mapgen::getMapgenType(const std::string &mgname) { for (size_t i = 0; i != ARRLEN(g_reg_mapgens); i++) { if (mgname == g_reg_mapgens[i].name) return (MapgenType)i; } return MAPGEN_INVALID; } const char *Mapgen::getMapgenName(MapgenType mgtype) { size_t index = (size_t)mgtype; if (index == MAPGEN_INVALID || index >= ARRLEN(g_reg_mapgens)) return "invalid"; return g_reg_mapgens[index].name; } Mapgen *Mapgen::createMapgen(MapgenType mgtype, MapgenParams *params, EmergeParams *emerge) { switch (mgtype) { case MAPGEN_CARPATHIAN: return new MapgenCarpathian((MapgenCarpathianParams *)params, emerge); case MAPGEN_FLAT: return new MapgenFlat((MapgenFlatParams *)params, emerge); case MAPGEN_FRACTAL: return new MapgenFractal((MapgenFractalParams *)params, emerge); case MAPGEN_SINGLENODE: return new MapgenSinglenode((MapgenSinglenodeParams *)params, emerge); case MAPGEN_V5: return new MapgenV5((MapgenV5Params *)params, emerge); case MAPGEN_V6: return new MapgenV6((MapgenV6Params *)params, emerge); case MAPGEN_V7: return new MapgenV7((MapgenV7Params *)params, emerge); case MAPGEN_VALLEYS: return new MapgenValleys((MapgenValleysParams *)params, emerge); default: return nullptr; } } MapgenParams *Mapgen::createMapgenParams(MapgenType mgtype) { switch (mgtype) { case MAPGEN_CARPATHIAN: return new MapgenCarpathianParams; case MAPGEN_FLAT: return new MapgenFlatParams; case MAPGEN_FRACTAL: return new MapgenFractalParams; case MAPGEN_SINGLENODE: return new MapgenSinglenodeParams; case MAPGEN_V5: return new MapgenV5Params; case MAPGEN_V6: return new MapgenV6Params; case MAPGEN_V7: return new MapgenV7Params; case MAPGEN_VALLEYS: return new MapgenValleysParams; default: return nullptr; } } void Mapgen::getMapgenNames(std::vector<const char *> *mgnames, bool include_hidden) { for (u32 i = 0; i != ARRLEN(g_reg_mapgens); i++) { if (include_hidden || g_reg_mapgens[i].is_user_visible) mgnames->push_back(g_reg_mapgens[i].name); } } void Mapgen::setDefaultSettings(Settings *settings) { settings->setDefault("mg_flags", flagdesc_mapgen, MG_CAVES | MG_DUNGEONS | MG_LIGHT | MG_DECORATIONS | MG_BIOMES); for (int i = 0; i < (int)MAPGEN_INVALID; ++i) { MapgenParams *params = createMapgenParams((MapgenType)i); params->setDefaultSettings(settings); delete params; } } u32 Mapgen::getBlockSeed(v3s16 p, s32 seed) { return (u32)seed + p.Z * 38134234 + p.Y * 42123 + p.X * 23; } u32 Mapgen::getBlockSeed2(v3s16 p, s32 seed) { u32 n = 1619 * p.X + 31337 * p.Y + 52591 * p.Z + 1013 * seed; n = (n >> 13) ^ n; return (n * (n * n * 60493 + 19990303) + 1376312589); } // Returns Y one under area minimum if not found s16 Mapgen::findGroundLevelFull(v2s16 p2d) { const v3s16 &em = vm->m_area.getExtent(); s16 y_nodes_max = vm->m_area.MaxEdge.Y; s16 y_nodes_min = vm->m_area.MinEdge.Y; u32 i = vm->m_area.index(p2d.X, y_nodes_max, p2d.Y); s16 y; for (y = y_nodes_max; y >= y_nodes_min; y--) { MapNode &n = vm->m_data[i]; if (ndef->get(n).walkable) break; VoxelArea::add_y(em, i, -1); } return (y >= y_nodes_min) ? y : y_nodes_min - 1; } // Returns -MAX_MAP_GENERATION_LIMIT if not found s16 Mapgen::findGroundLevel(v2s16 p2d, s16 ymin, s16 ymax) { const v3s16 &em = vm->m_area.getExtent(); u32 i = vm->m_area.index(p2d.X, ymax, p2d.Y); s16 y; for (y = ymax; y >= ymin; y--) { MapNode &n = vm->m_data[i]; if (ndef->get(n).walkable) break; VoxelArea::add_y(em, i, -1); } return (y >= ymin) ? y : -MAX_MAP_GENERATION_LIMIT; } // Returns -MAX_MAP_GENERATION_LIMIT if not found or if ground is found first s16 Mapgen::findLiquidSurface(v2s16 p2d, s16 ymin, s16 ymax) { const v3s16 &em = vm->m_area.getExtent(); u32 i = vm->m_area.index(p2d.X, ymax, p2d.Y); s16 y; for (y = ymax; y >= ymin; y--) { MapNode &n = vm->m_data[i]; if (ndef->get(n).walkable) return -MAX_MAP_GENERATION_LIMIT; if (ndef->get(n).isLiquid()) break; VoxelArea::add_y(em, i, -1); } return (y >= ymin) ? y : -MAX_MAP_GENERATION_LIMIT; } void Mapgen::updateHeightmap(v3s16 nmin, v3s16 nmax) { if (!heightmap) return; //TimeTaker t("Mapgen::updateHeightmap", NULL, PRECISION_MICRO); int index = 0; for (s16 z = nmin.Z; z <= nmax.Z; z++) { for (s16 x = nmin.X; x <= nmax.X; x++, index++) { s16 y = findGroundLevel(v2s16(x, z), nmin.Y, nmax.Y); heightmap[index] = y; } } } void Mapgen::getSurfaces(v2s16 p2d, s16 ymin, s16 ymax, std::vector<s16> &floors, std::vector<s16> &ceilings) { const v3s16 &em = vm->m_area.getExtent(); bool is_walkable = false; u32 vi = vm->m_area.index(p2d.X, ymax, p2d.Y); MapNode mn_max = vm->m_data[vi]; bool walkable_above = ndef->get(mn_max).walkable; VoxelArea::add_y(em, vi, -1); for (s16 y = ymax - 1; y >= ymin; y--) { MapNode mn = vm->m_data[vi]; is_walkable = ndef->get(mn).walkable; if (is_walkable && !walkable_above) { floors.push_back(y); } else if (!is_walkable && walkable_above) { ceilings.push_back(y + 1); } VoxelArea::add_y(em, vi, -1); walkable_above = is_walkable; } } inline bool Mapgen::isLiquidHorizontallyFlowable(u32 vi, v3s16 em) { u32 vi_neg_x = vi; VoxelArea::add_x(em, vi_neg_x, -1); if (vm->m_data[vi_neg_x].getContent() != CONTENT_IGNORE) { const ContentFeatures &c_nx = ndef->get(vm->m_data[vi_neg_x]); if (c_nx.floodable && !c_nx.isLiquid()) return true; } u32 vi_pos_x = vi; VoxelArea::add_x(em, vi_pos_x, +1); if (vm->m_data[vi_pos_x].getContent() != CONTENT_IGNORE) { const ContentFeatures &c_px = ndef->get(vm->m_data[vi_pos_x]); if (c_px.floodable && !c_px.isLiquid()) return true; } u32 vi_neg_z = vi; VoxelArea::add_z(em, vi_neg_z, -1); if (vm->m_data[vi_neg_z].getContent() != CONTENT_IGNORE) { const ContentFeatures &c_nz = ndef->get(vm->m_data[vi_neg_z]); if (c_nz.floodable && !c_nz.isLiquid()) return true; } u32 vi_pos_z = vi; VoxelArea::add_z(em, vi_pos_z, +1); if (vm->m_data[vi_pos_z].getContent() != CONTENT_IGNORE) { const ContentFeatures &c_pz = ndef->get(vm->m_data[vi_pos_z]); if (c_pz.floodable && !c_pz.isLiquid()) return true; } return false; } void Mapgen::updateLiquid(UniqueQueue<v3s16> *trans_liquid, v3s16 nmin, v3s16 nmax) { bool isignored, isliquid, wasignored, wasliquid, waschecked, waspushed; const v3s16 &em = vm->m_area.getExtent(); for (s16 z = nmin.Z + 1; z <= nmax.Z - 1; z++) for (s16 x = nmin.X + 1; x <= nmax.X - 1; x++) { wasignored = true; wasliquid = false; waschecked = false; waspushed = false; u32 vi = vm->m_area.index(x, nmax.Y, z); for (s16 y = nmax.Y; y >= nmin.Y; y--) { isignored = vm->m_data[vi].getContent() == CONTENT_IGNORE; isliquid = ndef->get(vm->m_data[vi]).isLiquid(); if (isignored || wasignored || isliquid == wasliquid) { // Neither topmost node of liquid column nor topmost node below column waschecked = false; waspushed = false; } else if (isliquid) { // This is the topmost node in the column bool ispushed = false; if (isLiquidHorizontallyFlowable(vi, em)) { trans_liquid->push_back(v3s16(x, y, z)); ispushed = true; } // Remember waschecked and waspushed to avoid repeated // checks/pushes in case the column consists of only this node waschecked = true; waspushed = ispushed; } else { // This is the topmost node below a liquid column u32 vi_above = vi; VoxelArea::add_y(em, vi_above, 1); if (!waspushed && (ndef->get(vm->m_data[vi]).floodable || (!waschecked && isLiquidHorizontallyFlowable(vi_above, em)))) { // Push back the lowest node in the column which is one // node above this one trans_liquid->push_back(v3s16(x, y + 1, z)); } } wasliquid = isliquid; wasignored = isignored; VoxelArea::add_y(em, vi, -1); } } } void Mapgen::setLighting(u8 light, v3s16 nmin, v3s16 nmax) { ScopeProfiler sp(g_profiler, "EmergeThread: update lighting", SPT_AVG); VoxelArea a(nmin, nmax); for (int z = a.MinEdge.Z; z <= a.MaxEdge.Z; z++) { for (int y = a.MinEdge.Y; y <= a.MaxEdge.Y; y++) { u32 i = vm->m_area.index(a.MinEdge.X, y, z); for (int x = a.MinEdge.X; x <= a.MaxEdge.X; x++, i++) vm->m_data[i].param1 = light; } } } void Mapgen::lightSpread(VoxelArea &a, std::queue<std::pair<v3s16, u8>> &queue, const v3s16 &p, u8 light) { if (light <= 1 || !a.contains(p)) return; u32 vi = vm->m_area.index(p); MapNode &n = vm->m_data[vi]; // Decay light in each of the banks separately u8 light_day = light & 0x0F; if (light_day > 0) light_day -= 0x01; u8 light_night = light & 0xF0; if (light_night > 0) light_night -= 0x10; // Bail out only if we have no more light from either bank to propogate, or // we hit a solid block that light cannot pass through. if ((light_day <= (n.param1 & 0x0F) && light_night <= (n.param1 & 0xF0)) || !ndef->get(n).light_propagates) return; // Since this recursive function only terminates when there is no light from // either bank left, we need to take the max of both banks into account for // the case where spreading has stopped for one light bank but not the other. light = MYMAX(light_day, n.param1 & 0x0F) | MYMAX(light_night, n.param1 & 0xF0); n.param1 = light; // add to queue queue.emplace(p, light); } void Mapgen::calcLighting(v3s16 nmin, v3s16 nmax, v3s16 full_nmin, v3s16 full_nmax, bool propagate_shadow) { ScopeProfiler sp(g_profiler, "EmergeThread: update lighting", SPT_AVG); //TimeTaker t("updateLighting"); propagateSunlight(nmin, nmax, propagate_shadow); spreadLight(full_nmin, full_nmax); //printf("updateLighting: %dms\n", t.stop()); } void Mapgen::propagateSunlight(v3s16 nmin, v3s16 nmax, bool propagate_shadow) { //TimeTaker t("propagateSunlight"); VoxelArea a(nmin, nmax); bool block_is_underground = (water_level >= nmax.Y); const v3s16 &em = vm->m_area.getExtent(); // NOTE: Direct access to the low 4 bits of param1 is okay here because, // by definition, sunlight will never be in the night lightbank. for (int z = a.MinEdge.Z; z <= a.MaxEdge.Z; z++) { for (int x = a.MinEdge.X; x <= a.MaxEdge.X; x++) { // see if we can get a light value from the overtop u32 i = vm->m_area.index(x, a.MaxEdge.Y + 1, z); if (vm->m_data[i].getContent() == CONTENT_IGNORE) { if (block_is_underground) continue; } else if ((vm->m_data[i].param1 & 0x0F) != LIGHT_SUN && propagate_shadow) { continue; } VoxelArea::add_y(em, i, -1); for (int y = a.MaxEdge.Y; y >= a.MinEdge.Y; y--) { MapNode &n = vm->m_data[i]; if (!ndef->get(n).sunlight_propagates) break; n.param1 = LIGHT_SUN; VoxelArea::add_y(em, i, -1); } } } //printf("propagateSunlight: %dms\n", t.stop()); } void Mapgen::spreadLight(const v3s16 &nmin, const v3s16 &nmax) { //TimeTaker t("spreadLight"); std::queue<std::pair<v3s16, u8>> queue; VoxelArea a(nmin, nmax); for (int z = a.MinEdge.Z; z <= a.MaxEdge.Z; z++) { for (int y = a.MinEdge.Y; y <= a.MaxEdge.Y; y++) { u32 i = vm->m_area.index(a.MinEdge.X, y, z); for (int x = a.MinEdge.X; x <= a.MaxEdge.X; x++, i++) { MapNode &n = vm->m_data[i]; if (n.getContent() == CONTENT_IGNORE) continue; const ContentFeatures &cf = ndef->get(n); if (!cf.light_propagates) continue; // TODO(hmmmmm): Abstract away direct param1 accesses with a // wrapper, but something lighter than MapNode::get/setLight u8 light_produced = cf.light_source; if (light_produced) n.param1 = light_produced | (light_produced << 4); u8 light = n.param1; if (light) { const v3s16 p(x, y, z); // spread to all 6 neighbor nodes for (const auto &dir : g_6dirs) lightSpread(a, queue, p + dir, light); } } } } while (!queue.empty()) { const auto &i = queue.front(); // spread to all 6 neighbor nodes for (const auto &dir : g_6dirs) lightSpread(a, queue, i.first + dir, i.second); queue.pop(); } //printf("spreadLight: %lums\n", t.stop()); } //// //// MapgenBasic //// MapgenBasic::MapgenBasic(int mapgenid, MapgenParams *params, EmergeParams *emerge) : Mapgen(mapgenid, params, emerge) { this->m_emerge = emerge; this->m_bmgr = emerge->biomemgr; //// Here, 'stride' refers to the number of elements needed to skip to index //// an adjacent element for that coordinate in noise/height/biome maps //// (*not* vmanip content map!) // Note there is no X stride explicitly defined. Items adjacent in the X // coordinate are assumed to be adjacent in memory as well (i.e. stride of 1). // Number of elements to skip to get to the next Y coordinate this->ystride = csize.X; // Number of elements to skip to get to the next Z coordinate this->zstride = csize.X * csize.Y; // Z-stride value for maps oversized for 1-down overgeneration this->zstride_1d = csize.X * (csize.Y + 1); // Z-stride value for maps oversized for 1-up 1-down overgeneration this->zstride_1u1d = csize.X * (csize.Y + 2); //// Allocate heightmap this->heightmap = new s16[csize.X * csize.Z]; //// Initialize biome generator biomegen = m_bmgr->createBiomeGen(BIOMEGEN_ORIGINAL, params->bparams, csize); biomemap = biomegen->biomemap; //// Look up some commonly used content c_stone = ndef->getId("mapgen_stone"); c_water_source = ndef->getId("mapgen_water_source"); c_river_water_source = ndef->getId("mapgen_river_water_source"); c_lava_source = ndef->getId("mapgen_lava_source"); c_cobble = ndef->getId("mapgen_cobble"); // Fall back to more basic content if not defined. // Lava falls back to water as both are suitable as cave liquids. if (c_lava_source == CONTENT_IGNORE) c_lava_source = c_water_source; if (c_stone == CONTENT_IGNORE) errorstream << "Mapgen: Mapgen alias 'mapgen_stone' is invalid!" << std::endl; if (c_water_source == CONTENT_IGNORE) errorstream << "Mapgen: Mapgen alias 'mapgen_water_source' is invalid!" << std::endl; if (c_river_water_source == CONTENT_IGNORE) warningstream << "Mapgen: Mapgen alias 'mapgen_river_water_source' is invalid!" << std::endl; } MapgenBasic::~MapgenBasic() { delete biomegen; delete []heightmap; delete m_emerge; // destroying EmergeParams is our responsibility } void MapgenBasic::generateBiomes() { // can't generate biomes without a biome generator! assert(biomegen); assert(biomemap); const v3s16 &em = vm->m_area.getExtent(); u32 index = 0; noise_filler_depth->perlinMap2D(node_min.X, node_min.Z);


context:
space:
mode: