init.lua

   1 --[=[ Main tables ]=]
   2
   3 playereffects = {}
   4
   5 --[[ table containing the groups (experimental) ]]
   6 playereffects.groups = {}
   7
   8 --[[ table containing all the effect types ]]
   9 playereffects.effect_types = {}
  10
  11 --[[ table containing all the active effects ]]
  12 playereffects.effects = {}
  13
  14 --[[ table containing all the inactive effects.
  15 Effects become inactive if a player leaves an become active again if they join again. ]]
  16 playereffects.inactive_effects = {}
  17
  18 -- Variable for counting the effect_id
  19 playereffects.last_effect_id = 0
  20
  21 --[=[ Include settings ]=]
  22 dofile(minetest.get_modpath("playereffects").."/settings.lua")
  23
  24 --[=[ Load inactive_effects and last_effect_id from playereffects.mt, if this file exists  ]=]
  25 do
  26         local filepath = minetest.get_worldpath().."/playereffects.mt"
  27         local file = io.open(filepath, "r")
  28         if file then
  29                 minetest.log("action", "[playereffects] playereffects.mt opened.")
  30                 local string = file:read()
  31                 io.close(file)
  32                 if(string ~= nil) then
  33                         local savetable = minetest.deserialize(string)
  34                         playereffects.inactive_effects = savetable.inactive_effects
  35                         minetest.debug("[playereffects] playereffects.mt successfully read.")
  36                         minetest.debug("[playereffects] inactive_effects = "..dump(playereffects.inactive_effects))
  37                         playereffects.last_effect_id = savetable.last_effect_id
  38                         minetest.debug("[playereffects] last_effect_id = "..dump(playereffects.last_effect_id))
  39
  40                 end
  41         end
  42 end
  43
  44 function playereffects.next_effect_id()
  45         playereffects.last_effect_id = playereffects.last_effect_id + 1
  46         return playereffects.last_effect_id
  47 end
  48
  49 --[=[ API functions ]=]
  50 function playereffects.register_effect_type(effect_type_id, description, icon, groups, apply, cancel, hidden, cancel_on_death)
  51         effect_type = {}
  52         effect_type.description = description
  53         effect_type.apply = apply
  54         effect_type.groups = groups
  55         effect_type.icon = icon
  56         if cancel ~= nil then
  57                 effect_type.cancel = cancel
  58         else
  59                 effect_type.cancel = function() end
  60         end
  61         if hidden ~= nil then
  62                 effect_type.hidden = hidden
  63         else
  64                 effect_type.hidden = false
  65         end
  66         if cancel_on_death ~= nil then
  67                 effect_type.cancel_on_death = cancel_on_death
  68         else
  69                 effect_type.cancel_on_death = true
  70         end
  71
  72         playereffects.effect_types[effect_type_id] = effect_type
  73         minetest.log("action", "[playereffects] Effect type "..effect_type_id.." registered!")
  74 end
  75
  76 function playereffects.apply_effect_type(effect_type_id, duration, player)
  77         local start_time = os.time()
  78         local is_player = false
  79         if(type(player)=="userdata") then
  80                 if(player.is_player ~= nil) then
  81                         if(player:is_player() == true) then
  82                                 is_player = true
  83                         end
  84                 end
  85         end
  86         if(is_player == false) then
  87                 minetest.log("error", "[playereffects] Attempted to apply effect type "..effect_type_id.." to a non-player!")
  88                 return false
  89         end
  90
  91         local playername = player:get_player_name()
  92         local groups = playereffects.effect_types[effect_type_id].groups
  93         for k,v in pairs(groups) do
  94                 playereffects.cancel_effect_group(v, playername)
  95         end
  96
  97         local status = playereffects.effect_types[effect_type_id].apply(player)
  98         local metadata
  99
 100         if(status == false) then
 101                 minetest.log("action", "[playereffects] Attempt to apply effect type "..effect_type_id.." to player "..playername.." failed!")
 102                 return false
 103         else
 104                 metadata = status
 105         end
 106
 107         local effect_id = playereffects.next_effect_id()
 108         local effects = playereffects.get_player_effects(playername)
 109         local smallest_hudpos
 110         local biggest_hudpos = -1
 111         local free_hudpos
 112         for e=1,#effects do
 113                 local hudpos = effects[e].hudpos
 114                 if(hudpos > biggest_hudpos) then
 115                         biggest_hudpos = hudpos
 116                 end
 117                 if(smallest_hudpos == nil) then
 118                         smallest_hudpos = hudpos
 119                 elseif(hudpos < smallest_hudpos) then
 120                         smallest_hudpos = hudpos
 121                 end
 122         end
 123         if(smallest_hudpos == nil) then
 124                 free_hudpos = 0
 125         elseif(smallest_hudpos >= 0) then
 126                 free_hudpos = smallest_hudpos - 1
 127         else
 128                 free_hudpos = biggest_hudpos + 1
 129         end
 130         local hudids
 131         --[[ show no more than 20 effects on the screen, so that hud_update does not need to be called so often ]]
 132         if(free_hudpos <= 20) then
 133                 hudids = playereffects.hud_effect(effect_type_id, player, free_hudpos, duration)
 134         else
 135                 hudids = {text_id=nil, icon_id=nil}
 136         end
 137
 138         local effect = {
 139                         playername = playername,
 140                         effect_id = effect_id,
 141                         effect_type_id = effect_type_id,
 142                         start_time = start_time,
 143                         time_left = duration,
 144                         hudids = hudids,
 145                         hudpos = free_hudpos,
 146                         metadata = metadata,
 147         }
 148
 149         playereffects.effects[effect_id] = effect
 150
 151         minetest.log("action", "[playereffects] Effect type "..effect_type_id.." applied to player "..playername.." (effect_id = "..effect_id..").")
 152         minetest.after(duration, function(effect_id) playereffects.cancel_effect(effect_id) end, effect_id)
 153
 154         return effect_id
 155 end
 156
 157 function playereffects.cancel_effect_type(effect_type_id, cancel_all, playername)
 158         local effects = playereffects.get_player_effects(playername)
 159         if(cancel_all==nil) then all = false end
 160         for e=1, #effects do
 161                 if(effects[e].effect_type_id == effect_type_id) then
 162                         playereffects.cancel_effect(effects[e].effect_id)
 163                         if(cancel_all==false) then
 164                                 return
 165                         end
 166                 end
 167         end
 168 end
 169
 170 function playereffects.cancel_effect_group(groupname, playername)
 171         local effects = playereffects.get_player_effects(playername)
 172         for e=1,#effects do
 173                 local effect = effects[e]
 174                 local thesegroups = playereffects.effect_types[effect.effect_type_id].groups
 175                 local delete = false
 176                 for g=1,#thesegroups do
 177                         if(thesegroups[g] == groupname) then
 178                                 playereffects.cancel_effect(effect.effect_id)
 179                                 break
 180                         end
 181                 end
 182         end
 183 end
 184
 185 function playereffects.cancel_effect(effect_id)
 186         local effect = playereffects.effects[effect_id]
 187         if(effect ~= nil) then
 188                 local player = minetest.get_player_by_name(effect.playername)
 189                 if(effect.hudids.text_id~=nil) then
 190                         player:hud_remove(effect.hudids.text_id)
 191                 end
 192                 if(effect.hudids.icon_id~=nil) then
 193                         player:hud_remove(effect.hudids.icon_id)
 194                 end
 195                 playereffects.effect_types[effect.effect_type_id].cancel(effect)
 196                 playereffects.effects[effect_id] = nil
 197                 minetest.log("action", "[playereffects] Effect type "..effect.effect_type_id.." cancelled from player "..effect.playername.."!")
 198         end
 199 end
 200
 201 function playereffects.get_player_effects(playername)
 202         if(minetest.get_player_by_name(playername) ~= nil) then
 203                 local effects = {}
 204                 for k,v in pairs(playereffects.effects) do
 205                         if(v.playername == playername) then
 206                                 table.insert(effects, v)
 207                         end
 208                 end
 209                 return effects
 210         else
 211                 return {}
 212         end
 213 end
 214
 215 --[=[ Saving all data to file ]=]
 216 function playereffects.save_to_file()
 217         local save_time = os.time()
 218         local savetable = {}
 219         local inactive_effects = {}
 220         for id,effecttable in pairs(playereffects.inactive_effects) do
 221                 local playername = id
 222                 if(inactive_effects[playername] == nil) then
 223                         inactive_effects[playername] = {}
 224                 end
 225                 for i=1,#effecttable do
 226                         table.insert(inactive_effects[playername], effecttable[i])
 227                 end
 228         end
 229         for id,effect in pairs(playereffects.effects) do
 230                 local new_duration = effect.time_left - os.difftime(save_time, effect.start_time)
 231                 local new_effect = {
 232                         effect_id = effect.effect_id,
 233                         effect_type_id = effect.effect_type_id,
 234                         time_left = new_duration,
 235                         start_time = effect.start_time,
 236                         playername = effect.playername,
 237                         metadata = effect.metadata
 238                 }
 239                 if(inactive_effects[effect.playername] == nil) then
 240                         inactive_effects[effect.playername] = {}
 241                 end
 242                 table.insert(inactive_effects[effect.playername], new_effect)
 243         end
 244
 245         savetable.inactive_effects = inactive_effects
 246         savetable.last_effect_id = playereffects.last_effect_id
 247
 248         local savestring = minetest.serialize(savetable)
 249
 250         local filepath = minetest.get_worldpath().."/playereffects.mt"
 251         local file = io.open(filepath, "w")
 252         if file then
 253                 file:write(savestring)
 254                 io.close(file)
 255                 minetest.log("action", "[playereffects] Wrote playereffects data into "..filepath..".")
 256         else
 257                 minetest.log("error", "[playereffects] Failed to write playereffects data into "..filepath..".")
 258         end
 259 end
 260
 261 --[=[ Callbacks ]=]
 262 --[[ Cancel all effects on player death ]]
 263 minetest.register_on_dieplayer(function(player)
 264         local effects = playereffects.get_player_effects(player:get_player_name())
 265         for e=1,#effects do
 266                 if(playereffects.effect_types[effects[e].effect_type_id].cancel_on_death == true) then
 267                         playereffects.cancel_effect(effects[e].effect_id)
 268                 end
 269         end
 270 end)
 271
 272
 273 minetest.register_on_leaveplayer(function(player)
 274         local leave_time = os.time()
 275         local playername = player:get_player_name()
 276         local effects = playereffects.get_player_effects(playername)
 277
 278         playereffects.hud_clear(player)
 279
 280         if(playereffects.inactive_effects[playername] == nil) then
 281                 playereffects.inactive_effects[playername] = {}
 282         end
 283         for e=1,#effects do
 284                 local new_duration = effects[e].time_left - os.difftime(leave_time, effects[e].start_time)
 285                 local new_effect = effects[e]
 286                 new_effect.time_left = new_duration
 287                 table.insert(playereffects.inactive_effects[playername], new_effect)
 288                 playereffects.cancel_effect(effects[e].effect_id)
 289         end
 290 end)
 291
 292 minetest.register_on_shutdown(function()
 293         minetest.log("action", "[playereffects] Server shuts down. Rescuing data into playereffects.mt")
 294         playereffects.save_to_file()
 295 end)
 296
 297 minetest.register_on_joinplayer(function(player)
 298         local playername = player:get_player_name()
 299
 300         -- load all the effects again (if any)
 301         if(playereffects.inactive_effects[playername] ~= nil) then
 302                 for i=1,#playereffects.inactive_effects[playername] do
 303                         local effect = playereffects.inactive_effects[playername][i]
 304                         playereffects.apply_effect_type(effect.effect_type_id, effect.time_left, player)
 305                 end
 306                 playereffects.inactive_effects[playername] = nil
 307         end
 308 end)
 309
 310 playereffects.globalstep_timer = 0
 311 playereffects.autosave_timer = 0
 312 minetest.register_globalstep(function(dtime)
 313         playereffects.globalstep_timer = playereffects.globalstep_timer + dtime
 314         playereffects.autosave_timer = playereffects.autosave_timer + dtime
 315         -- Update HUDs of all players
 316         if(playereffects.globalstep_timer >= 1) then
 317                 playereffects.globalstep_timer = 0
 318
 319                 local players = minetest.get_connected_players()
 320                 for p=1,#players do
 321                         playereffects.hud_update(players[p])
 322                 end
 323         end
 324         -- Autosave into file
 325         if(playereffects.use_autosave == true and playereffects.autosave_timer >= playereffects.autosave_time) then
 326                 playereffects.autosave_timer = 0
 327                 minetest.log("action", "[playereffects] Autosaving mod data to playereffects.mt ...")
 328                 playereffects.save_to_file()
 329         end
 330 end)
 331
 332
 333
 334
 335 --[=[ HUD ]=]
 336 function playereffects.hud_update(player)
 337         if(playereffects.use_hud == true) then
 338                 local now = os.time()
 339                 local effects = playereffects.get_player_effects(player:get_player_name())
 340                 for e=1,#effects do
 341                         local effect = effects[e]
 342                         if(effect.hudids.text_id ~= nil) then
 343                                 local description = playereffects.effect_types[effect.effect_type_id].description
 344                                 local time_left = os.difftime(effect.start_time + effect.time_left, now)
 345                                 player:hud_change(effect.hudids.text_id, "text", description .. " ("..tostring(time_left).." s)")
 346                         end
 347                 end
 348         end
 349 end
 350
 351 function playereffects.hud_clear(player)
 352         if(playereffects.use_hud == true) then
 353                 local playername = player:get_player_name()
 354                 local effects = playereffects.get_player_effects(playername)
 355                 if(effects ~= nil) then
 356                         for e=1,#effects do
 357                                 if(effects[e].hudids.text_id ~= nil) then
 358                                         player:hud_remove(effects[e].hudids.text_id)
 359                                 end
 360                                 if(effects[e].hudids.icon_id ~= nil) then
 361                                         player:hud_remove(effects[e].hudids.icon_id)
 362                                 end
 363                         end
 364                 end
 365         end
 366 end
 367
 368 function playereffects.hud_effect(effect_type_id, player, pos, time_left)
 369         local text_id, icon_id
 370         local effect_type = playereffects.effect_types[effect_type_id]
 371         if(playereffects.use_hud == true and effect_type.hidden == false) then
 372                 local color
 373                 if(playereffects.effect_types[effect_type_id].cancel_on_death == true) then
 374                         color = 0xFFFFFF
 375                 else
 376                         color = 0xF0BAFF
 377                 end
 378                 text_id = player:hud_add({
 379                         hud_elem_type = "text",
 380                         position = { x = 1, y = 0.3 },
 381                         name = "effect_"..effect_type_id,
 382                         text = playereffects.effect_types[effect_type_id].description .. " ("..tostring(time_left).." s)",
 383                         scale = { x = 170, y = 20},
 384                         alignment = { x = -1, y = 0 },
 385                         direction = 1,
 386                         number = color,
 387                         offset = { x = -5, y = pos*20 }
 388                 })
 389                 if(playereffects.effect_types[effect_type_id].icon ~= nil) then
 390                         icon_id = player:hud_add({
 391                                 hud_elem_type = "image",
 392                                 scale = { x = 1, y = 1 },
 393                                 position = { x = 1, y = 0.3 },
 394                                 name = "effect_icon_"..effect_type_id,
 395                                 text = playereffects.effect_types[effect_type_id].icon,
 396                                 alignment = { x = -1, y=0 },
 397                                 direction = 0,
 398                                 offset = { x = -186, y = pos*20 },
 399                         })
 400                 end
 401         else
 402                 text_id = nil
 403                 icon_id = nil
 404         end
 405         return { text_id = text_id, icon_id = icon_id }
 406 end
 407
 408
 409 -- LOAD EXAMPLES
 410 dofile(minetest.get_modpath(minetest.get_current_modname()).."/examples.lua")