mods/new_functions/init.lua

   1 local minetest,math,vector,table = minetest,math,vector,table
   2
   3 local pool = {}
   4
   5
   6 local name
   7 get_player_head_env = function(player)
   8         name = player:get_player_name()
   9         return(pool[name].head)
  10 end
  11 local name
  12 get_player_legs_env = function(player)
  13         name = player:get_player_name()
  14         return(pool[name].legs)
  15 end
  16
  17 local name
  18 player_under_check = function(player)
  19         name = player:get_player_name()
  20         return(pool[name].under)
  21 end
  22
  23 local name
  24 player_swim_check = function(player)
  25         name = player:get_player_name()
  26         return(minetest.get_nodedef(pool[name].swim_check, "walkable") == false)
  27 end
  28
  29 local name
  30 player_swim_under_check = function(player)
  31         name = player:get_player_name()
  32         return(minetest.get_nodedef(pool[name].under, "walkable") == false)
  33 end
  34
  35 -- create blank list for player environment data
  36 local name
  37 local temp_pool
  38 minetest.register_on_joinplayer(function(player)
  39         name = player:get_player_name()
  40         pool[name] = {}
  41         temp_pool = pool[name]
  42
  43         temp_pool.under  = ""
  44         temp_pool.legs   = ""
  45         temp_pool.head   = ""
  46         temp_pool.swim_check = ""
  47         temp_pool.touch_hurt_ticker  = 0
  48         temp_pool.hurt_inside_ticker = 0
  49 end)
  50
  51 -- destroy player environment data
  52 local name
  53 minetest.register_on_leaveplayer(function(player)
  54         name = player:get_player_name()
  55         pool[name] = nil
  56 end)
  57
  58
  59
  60 -- handle damage when touching node
  61 -- this is lua collision detection
  62 -- damages players 4 times a second
  63 local name
  64 local temp_pool
  65 local tick
  66 local handle_touch_hurting = function(player,damage,dtime)
  67         name      = player:get_player_name()
  68         temp_pool = pool[name]
  69         tick      = temp_pool.touch_hurt_ticker
  70
  71         tick = tick - dtime
  72         if tick <= 0 then
  73                 player:set_hp(player:get_hp()-damage)
  74                 tick = 0.25
  75         end
  76         temp_pool.touch_hurt_ticker = tick
  77 end
  78
  79
  80 local pos
  81 local hurt
  82 local name
  83 local damage_nodes
  84 local real_nodes
  85 local a_min
  86 local a_max
  87 local damage_amount
  88 local gotten_node
  89 local _
  90 local hurt_collide = function(player,dtime)
  91         name = player:get_player_name()
  92         if player:get_hp() <= 0 then
  93                 return
  94         end
  95         -- used for finding a damage node from the center of the player
  96         -- rudementary collision detection
  97         pos = player:get_pos()
  98         pos.y = pos.y + (player:get_properties().collisionbox[5]/2)
  99         a_min = vector.new(
 100                 pos.x-0.25,
 101                 pos.y-0.9,
 102                 pos.z-0.25
 103         )
 104         a_max = vector.new(
 105                 pos.x+0.25,
 106                 pos.y+0.9,
 107                 pos.z+0.25
 108         )
 109
 110         _,damage_nodes = minetest.find_nodes_in_area( a_min,  a_max, {"group:touch_hurt"})
 111         real_nodes = {}
 112         for node_data,is_next_to in pairs(damage_nodes) do
 113                 if damage_nodes[node_data] > 0 then
 114                         table.insert(real_nodes,node_data)
 115                 end
 116         end
 117         hurt = 0
 118         -- find the highest damage node
 119         if table.getn(real_nodes) > 0 then
 120                 for _,node in ipairs(real_nodes) do
 121                         damage_amount = minetest.get_item_group(node, "touch_hurt")
 122                         if damage_amount >  hurt then
 123                                 hurt = damage_amount
 124                         end
 125                 end
 126                 handle_touch_hurting(player,damage_amount,dtime)
 127         else
 128                 pool[name].touch_hurt_ticker = 0
 129         end
 130 end
 131
 132
 133
 134 -- handle damage when inside node
 135 -- this is lua collision detection
 136
 137 -- damages players 4 times a second
 138 local name
 139 local temp_pool
 140 local tick
 141 local handle_hurt_inside = function(player,damage,dtime)
 142         name      = player:get_player_name()
 143         temp_pool = pool[name]
 144         tick      = temp_pool.hurt_inside_ticker
 145
 146         tick = tick - dtime
 147         if tick <= 0 then
 148                 player:set_hp(player:get_hp()-damage)
 149                 tick = 0.25
 150         end
 151         temp_pool.hurt_inside_ticker = tick
 152 end
 153
 154 local pos
 155 local hurt
 156 local name
 157 local damage_nodes
 158 local real_nodes
 159 local a_min
 160 local a_max
 161 local damage_amount
 162 local gotten_node
 163 local _
 164 local hurt_inside = function(player,dtime)
 165         name = player:get_player_name()
 166         if player:get_hp() <= 0 then
 167                 return
 168         end
 169         -- used for finding a damage node from the center of the player
 170         -- rudementary collision detection
 171         pos = player:get_pos()
 172         pos.y = pos.y + (player:get_properties().collisionbox[5]/2)
 173         a_min = vector.new(
 174                 pos.x-0.25,
 175                 pos.y-0.85,
 176                 pos.z-0.25
 177         )
 178         a_max = vector.new(
 179                 pos.x+0.25,
 180                 pos.y+0.85,
 181                 pos.z+0.25
 182         )
 183
 184         _,damage_nodes = minetest.find_nodes_in_area( a_min,  a_max, {"group:hurt_inside"})
 185         real_nodes = {}
 186         for node_data,is_next_to in pairs(damage_nodes) do
 187                 if damage_nodes[node_data] > 0 then
 188                         table.insert(real_nodes,node_data)
 189                 end
 190         end
 191         hurt = 0
 192         -- find the highest damage node
 193         if table.getn(real_nodes) > 0 then
 194                 for _,node in ipairs(real_nodes) do
 195                         damage_amount = minetest.get_item_group(node, "hurt_inside")
 196                         if damage_amount >  hurt then
 197                                 hurt = damage_amount
 198                         end
 199                 end
 200                 handle_hurt_inside(player,damage_amount,dtime)
 201         else
 202                 pool[name].hurt_inside_ticker = 0
 203         end
 204 end
 205
 206
 207
 208
 209 -- this handles lighting a player on fire
 210 local pos
 211 local name
 212 local damage_nodes
 213 local real_nodes
 214 local a_min
 215 local a_max
 216 local _
 217 local light
 218 local head_pos
 219 local start_fire = function(player)
 220         name = player:get_player_name()
 221         if player:get_hp() <= 0 then
 222                 return
 223         end
 224
 225         pos = player:get_pos()
 226
 227         if weather_type == 2 then
 228                 head_pos = table.copy(pos)
 229                 head_pos.y = head_pos.y + player:get_properties().collisionbox[5]
 230                 light = minetest.get_node_light(head_pos, 0.5)
 231                 if light and light == 15 then
 232                         return
 233                 end
 234         end
 235
 236         -- used for finding a damage node from the center of the player
 237         -- rudementary collision detection
 238         pos.y = pos.y + (player:get_properties().collisionbox[5]/2)
 239         a_min = vector.new(
 240                 pos.x-0.25,
 241                 pos.y-0.85,
 242                 pos.z-0.25
 243         )
 244         a_max = vector.new(
 245                 pos.x+0.25,
 246                 pos.y+0.85,
 247                 pos.z+0.25
 248         )
 249
 250         _,damage_nodes = minetest.find_nodes_in_area( a_min,  a_max, {"group:fire"})
 251         real_nodes = {}
 252         for node_data,is_next_to in pairs(damage_nodes) do
 253                 if damage_nodes[node_data] > 0 then
 254                         table.insert(real_nodes,node_data)
 255                 end
 256         end
 257
 258         if table.getn(real_nodes) > 0 then
 259                 start_fire(player)
 260         end
 261 end
 262
 263 -- this handles extinguishing a fire
 264 local pos
 265 local name
 266 local relief_nodes
 267 local real_nodes
 268 local a_min
 269 local a_max
 270 local _
 271 local light
 272 local head_pos
 273 local extinguish = function(player)
 274         name = player:get_player_name()
 275         if player:get_hp() <= 0 then
 276                 return
 277         end
 278         pos = player:get_pos()
 279         if weather_type == 2 then
 280                 head_pos = table.copy(pos)
 281                 head_pos.y = head_pos.y + player:get_properties().collisionbox[5]
 282                 light = minetest.get_node_light(head_pos, 0.5)
 283                 if light and light == 15 then
 284                         put_fire_out(player)
 285                         return
 286                 end
 287         end
 288         -- used for finding a damage node from the center of the player
 289         -- rudementary collision detection
 290         pos.y = pos.y + (player:get_properties().collisionbox[5]/2)
 291         a_min = vector.new(
 292                 pos.x-0.25,
 293                 pos.y-0.85,
 294                 pos.z-0.25
 295         )
 296         a_max = vector.new(
 297                 pos.x+0.25,
 298                 pos.y+0.85,
 299                 pos.z+0.25
 300         )
 301
 302         _,relief_nodes = minetest.find_nodes_in_area( a_min,  a_max, {"group:extinguish"})
 303         real_nodes = {}
 304         for node_data,is_next_to in pairs(relief_nodes) do
 305                 if relief_nodes[node_data] > 0 then
 306                         table.insert(real_nodes,node_data)
 307                 end
 308         end
 309
 310         if table.getn(real_nodes) > 0 then
 311                 put_fire_out(player)
 312         end
 313 end
 314 --[[
 315 -- handle player suffocating inside solid node
 316 environment_class.handle_player_suffocation = function(player,dtime)
 317         if player:get_hp() <= 0 then
 318                 return
 319         end
 320
 321         local data = environment_class.get_data(player,{"head"})
 322
 323         if data then
 324                 data = data.head
 325                 if minetest.get_nodedef(data, "drawtype") == "normal" then
 326                         environment_class.handle_suffocation_hurt(player,1,dtime)
 327                 else
 328                         environment_class.set_data(player,{suffocation_ticker = 0})
 329                 end
 330         end
 331 end
 332
 333 -- damages players 4 times a second
 334 environment_class.handle_suffocation_hurt = function(player,damage,dtime)
 335         environment_class.tick = environment_class.get_data(player,{"suffocation_ticker"})
 336         if environment_class.tick then
 337                 environment_class.tick = environment_class.tick.suffocation_ticker
 338         end
 339         if not environment_class.tick then
 340                 environment_class.set_data(player,{suffocation_ticker = 0.25})
 341                 player:set_hp(player:get_hp()-damage)
 342         else
 343                 environment_class.tick = environment_class.tick - dtime
 344                 if environment_class.tick <= 0 then
 345                         player:set_hp(player:get_hp()-damage)
 346                         environment_class.set_data(player,{suffocation_ticker = 0.25})
 347                 else
 348                         environment_class.set_data(player,{suffocation_ticker = environment_class.tick})
 349                 end
 350         end
 351 end
 352
 353 ]]--
 354
 355 -- environment indexing
 356
 357 -- creates data at specific points of the player
 358 local name
 359 local temp_pool
 360 local pos
 361 local swimming
 362 local index_players_surroundings = function(dtime)
 363         for _,player in ipairs(minetest.get_connected_players()) do
 364
 365                 name = player:get_player_name()
 366                 temp_pool = pool[name]
 367
 368                 pos = player:get_pos()
 369                 swimming = is_player_swimming(player)
 370
 371                 if swimming then
 372                         --this is where the legs would be
 373                         temp_pool.under = minetest.get_node(pos).name
 374
 375                         --legs and head are in the same position
 376                         pos.y = pos.y + 1.35
 377                         temp_pool.legs = minetest.get_node(pos).name
 378                         temp_pool.head = minetest.get_node(pos).name
 379
 380                         pos.y = pos.y + 0.7
 381                         temp_pool.swim_check = minetest.get_node(pos).name
 382                 else
 383                         pos.y = pos.y - 0.1
 384                         temp_pool.under = minetest.get_node(pos).name
 385
 386                         pos.y = pos.y + 0.6
 387                         temp_pool.legs = minetest.get_node(pos).name
 388
 389                         pos.y = pos.y + 0.940
 390                         temp_pool.head = minetest.get_node(pos).name
 391                 end
 392
 393                 hurt_collide(player,dtime)
 394
 395                 hurt_inside(player,dtime)
 396
 397                 start_fire(player)
 398
 399                 if is_player_on_fire(player) then
 400                         extinguish(player)
 401                 end
 402                 --handle_player_suffocation(player,dtime)
 403         end
 404 end
 405
 406 -- insert all indexing data into main loop
 407 minetest.register_globalstep(function(dtime)
 408         index_players_surroundings(dtime)
 409 end)
 410
 411 -- a custom helper function
 412 minetest.get_nodedef = function(nodename, fieldname)
 413         if not minetest.registered_nodes[nodename] then
 414                 return nil
 415         end
 416         return minetest.registered_nodes[nodename][fieldname]
 417 end
 418
 419 -- a custom helper function
 420 minetest.get_itemdef = function(itemname, fieldname)
 421         if not minetest.registered_items[itemname] then
 422                 return nil
 423         end
 424         return minetest.registered_items[itemname][fieldname]
 425 end