src/script/lua_api/l_env.h

   1 /*
   2 Minetest
   3 Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #pragma once
  21
  22 #include "lua_api/l_base.h"
  23 #include "serverenvironment.h"
  24 #include "raycast.h"
  25
  26 class ModApiEnvMod : public ModApiBase {
  27 private:
  28         // set_node(pos, node)
  29         // pos = {x=num, y=num, z=num}
  30         static int l_set_node(lua_State *L);
  31
  32         // bulk_set_node([pos1, pos2, ...], node)
  33         // pos = {x=num, y=num, z=num}
  34         static int l_bulk_set_node(lua_State *L);
  35
  36         static int l_add_node(lua_State *L);
  37
  38         // remove_node(pos)
  39         // pos = {x=num, y=num, z=num}
  40         static int l_remove_node(lua_State *L);
  41
  42         // swap_node(pos, node)
  43         // pos = {x=num, y=num, z=num}
  44         static int l_swap_node(lua_State *L);
  45
  46         // get_node(pos)
  47         // pos = {x=num, y=num, z=num}
  48         static int l_get_node(lua_State *L);
  49
  50         // get_node_or_nil(pos)
  51         // pos = {x=num, y=num, z=num}
  52         static int l_get_node_or_nil(lua_State *L);
  53
  54         // get_node_light(pos, timeofday)
  55         // pos = {x=num, y=num, z=num}
  56         // timeofday: nil = current time, 0 = night, 0.5 = day
  57         static int l_get_node_light(lua_State *L);
  58
  59         // place_node(pos, node)
  60         // pos = {x=num, y=num, z=num}
  61         static int l_place_node(lua_State *L);
  62
  63         // dig_node(pos)
  64         // pos = {x=num, y=num, z=num}
  65         static int l_dig_node(lua_State *L);
  66
  67         // punch_node(pos)
  68         // pos = {x=num, y=num, z=num}
  69         static int l_punch_node(lua_State *L);
  70
  71         // get_node_max_level(pos)
  72         // pos = {x=num, y=num, z=num}
  73         static int l_get_node_max_level(lua_State *L);
  74
  75         // get_node_level(pos)
  76         // pos = {x=num, y=num, z=num}
  77         static int l_get_node_level(lua_State *L);
  78
  79         // set_node_level(pos)
  80         // pos = {x=num, y=num, z=num}
  81         static int l_set_node_level(lua_State *L);
  82
  83         // add_node_level(pos)
  84         // pos = {x=num, y=num, z=num}
  85         static int l_add_node_level(lua_State *L);
  86
  87         // find_nodes_with_meta(pos1, pos2)
  88         static int l_find_nodes_with_meta(lua_State *L);
  89
  90         // get_meta(pos)
  91         static int l_get_meta(lua_State *L);
  92
  93         // get_node_timer(pos)
  94         static int l_get_node_timer(lua_State *L);
  95
  96         // add_entity(pos, entityname) -> ObjectRef or nil
  97         // pos = {x=num, y=num, z=num}
  98         static int l_add_entity(lua_State *L);
  99
 100         // add_item(pos, itemstack or itemstring or table) -> ObjectRef or nil
 101         // pos = {x=num, y=num, z=num}
 102         static int l_add_item(lua_State *L);
 103
 104         // get_player_by_name(name)
 105         static int l_get_player_by_name(lua_State *L);
 106
 107         // get_objects_inside_radius(pos, radius)
 108         static int l_get_objects_inside_radius(lua_State *L);
 109
 110         // set_timeofday(val)
 111         // val = 0...1
 112         static int l_set_timeofday(lua_State *L);
 113
 114         // get_timeofday() -> 0...1
 115         static int l_get_timeofday(lua_State *L);
 116
 117         // get_gametime()
 118         static int l_get_gametime(lua_State *L);
 119
 120         // get_day_count() -> int
 121         static int l_get_day_count(lua_State *L);
 122
 123         // find_node_near(pos, radius, nodenames, search_center) -> pos or nil
 124         // nodenames: eg. {"ignore", "group:tree"} or "default:dirt"
 125         static int l_find_node_near(lua_State *L);
 126
 127         // find_nodes_in_area(minp, maxp, nodenames) -> list of positions
 128         // nodenames: eg. {"ignore", "group:tree"} or "default:dirt"
 129         static int l_find_nodes_in_area(lua_State *L);
 130
 131         // find_surface_nodes_in_area(minp, maxp, nodenames) -> list of positions
 132         // nodenames: eg. {"ignore", "group:tree"} or "default:dirt"
 133         static int l_find_nodes_in_area_under_air(lua_State *L);
 134
 135         // fix_light(p1, p2) -> true/false
 136         static int l_fix_light(lua_State *L);
 137
 138         // load_area(p1)
 139         static int l_load_area(lua_State *L);
 140
 141         // emerge_area(p1, p2)
 142         static int l_emerge_area(lua_State *L);
 143
 144         // delete_area(p1, p2) -> true/false
 145         static int l_delete_area(lua_State *L);
 146
 147         // get_perlin(seeddiff, octaves, persistence, scale)
 148         // returns world-specific PerlinNoise
 149         static int l_get_perlin(lua_State *L);
 150
 151         // get_perlin_map(noiseparams, size)
 152         // returns world-specific PerlinNoiseMap
 153         static int l_get_perlin_map(lua_State *L);
 154
 155         // get_voxel_manip()
 156         // returns world-specific voxel manipulator
 157         static int l_get_voxel_manip(lua_State *L);
 158
 159         // clear_objects()
 160         // clear all objects in the environment
 161         static int l_clear_objects(lua_State *L);
 162
 163         // spawn_tree(pos, treedef)
 164         static int l_spawn_tree(lua_State *L);
 165
 166         // line_of_sight(pos1, pos2) -> true/false
 167         static int l_line_of_sight(lua_State *L);
 168
 169         // raycast(pos1, pos2, objects, liquids) -> Raycast
 170         static int l_raycast(lua_State *L);
 171
 172         // find_path(pos1, pos2, searchdistance,
 173         //     max_jump, max_drop, algorithm) -> table containing path
 174         static int l_find_path(lua_State *L);
 175
 176         // transforming_liquid_add(pos)
 177         static int l_transforming_liquid_add(lua_State *L);
 178
 179         // forceload_block(blockpos)
 180         // forceloads a block
 181         static int l_forceload_block(lua_State *L);
 182
 183         // forceload_free_block(blockpos)
 184         // stops forceloading a position
 185         static int l_forceload_free_block(lua_State *L);
 186
 187 public:
 188         static void Initialize(lua_State *L, int top);
 189         static void InitializeClient(lua_State *L, int top);
 190
 191         static struct EnumString es_ClearObjectsMode[];
 192 };
 193
 194 class LuaABM : public ActiveBlockModifier {
 195 private:
 196         int m_id;
 197
 198         std::vector<std::string> m_trigger_contents;
 199         std::vector<std::string> m_required_neighbors;
 200         float m_trigger_interval;
 201         u32 m_trigger_chance;
 202         bool m_simple_catch_up;
 203 public:
 204         LuaABM(lua_State *L, int id,
 205                         const std::vector<std::string> &trigger_contents,
 206                         const std::vector<std::string> &required_neighbors,
 207                         float trigger_interval, u32 trigger_chance, bool simple_catch_up):
 208                 m_id(id),
 209                 m_trigger_contents(trigger_contents),
 210                 m_required_neighbors(required_neighbors),
 211                 m_trigger_interval(trigger_interval),
 212                 m_trigger_chance(trigger_chance),
 213                 m_simple_catch_up(simple_catch_up)
 214         {
 215         }
 216         virtual const std::vector<std::string> &getTriggerContents() const
 217         {
 218                 return m_trigger_contents;
 219         }
 220         virtual const std::vector<std::string> &getRequiredNeighbors() const
 221         {
 222                 return m_required_neighbors;
 223         }
 224         virtual float getTriggerInterval()
 225         {
 226                 return m_trigger_interval;
 227         }
 228         virtual u32 getTriggerChance()
 229         {
 230                 return m_trigger_chance;
 231         }
 232         virtual bool getSimpleCatchUp()
 233         {
 234                 return m_simple_catch_up;
 235         }
 236         virtual void trigger(ServerEnvironment *env, v3s16 p, MapNode n,
 237                         u32 active_object_count, u32 active_object_count_wider);
 238 };
 239
 240 class LuaLBM : public LoadingBlockModifierDef
 241 {
 242 private:
 243         int m_id;
 244 public:
 245         LuaLBM(lua_State *L, int id,
 246                         const std::set<std::string> &trigger_contents,
 247                         const std::string &name,
 248                         bool run_at_every_load):
 249                 m_id(id)
 250         {
 251                 this->run_at_every_load = run_at_every_load;
 252                 this->trigger_contents = trigger_contents;
 253                 this->name = name;
 254         }
 255         virtual void trigger(ServerEnvironment *env, v3s16 p, MapNode n);
 256 };
 257
 258 //! Lua wrapper for RaycastState objects
 259 class LuaRaycast : public ModApiBase
 260 {
 261 private:
 262         static const char className[];
 263         static const luaL_Reg methods[];
 264         //! Inner state
 265         RaycastState state;
 266
 267         // Exported functions
 268
 269         // garbage collector
 270         static int gc_object(lua_State *L);
 271
 272         /*!
 273          * Raycast:next() -> pointed_thing
 274          * Returns the next pointed thing on the ray.
 275          */
 276         static int l_next(lua_State *L);
 277 public:
 278         //! Constructor with the same arguments as RaycastState.
 279         LuaRaycast(
 280                 const core::line3d<f32> &shootline,
 281                 bool objects_pointable,
 282                 bool liquids_pointable) :
 283                 state(shootline, objects_pointable, liquids_pointable)
 284         {}
 285
 286         //! Creates a LuaRaycast and leaves it on top of the stack.
 287         static int create_object(lua_State *L);
 288
 289         /*!
 290          * Returns the Raycast from the stack or throws an error.
 291          * @param narg location of the RaycastState in the stack
 292          */
 293         static LuaRaycast *checkobject(lua_State *L, int narg);
 294
 295         //! Registers Raycast as a Lua userdata type.
 296         static void Register(lua_State *L);
 297 };
 298
 299 struct ScriptCallbackState {
 300         ServerScripting *script;
 301         int callback_ref;
 302         int args_ref;
 303         unsigned int refcount;
 304         std::string origin;
 305 };