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(name, description, icon, groups, apply, cancel, hidden)
  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         playereffects.effect_types[name] = effect_type
  67         minetest.log("action", "[playereffects] Effect type "..name.." registered!")
  68 end
  69
  70 function playereffects.apply_effect_type(effect_type_id, duration, player)
  71         local start_time = os.time()
  72         local playername = player:get_player_name()
  73         local groups = playereffects.effect_types[effect_type_id].groups
  74         for k,v in pairs(groups) do
  75                 playereffects.cancel_effect_group(v, playername)
  76         end
  77         local effect_id = playereffects.next_effect_id()
  78         local effects = playereffects.get_player_effects(playername)
  79         local smallest_hudpos
  80         local biggest_hudpos = -1
  81         local free_hudpos
  82         for e=1,#effects do
  83                 local hudpos = effects[e].hudpos
  84                 if(hudpos > biggest_hudpos) then
  85                         biggest_hudpos = hudpos
  86                 end
  87                 if(smallest_hudpos == nil) then
  88                         smallest_hudpos = hudpos
  89                 elseif(hudpos < smallest_hudpos) then
  90                         smallest_hudpos = hudpos
  91                 end
  92         end
  93         if(smallest_hudpos == nil) then
  94                 free_hudpos = 0
  95         elseif(smallest_hudpos >= 0) then
  96                 free_hudpos = smallest_hudpos - 1
  97         else
  98                 free_hudpos = biggest_hudpos + 1
  99         end
 100         local hudids
 101         --[[ show no more than 20 effects on the screen, so that hud_update does not need to be called so often ]]
 102         if(free_hudpos <= 20) then
 103                 hudids = playereffects.hud_effect(effect_type_id, player, free_hudpos, duration)
 104         else
 105                 hudids = {text_id=nil, icon_id=nil}
 106         end
 107
 108         local effect = {
 109                         playername = playername,
 110                         effect_id = effect_id,
 111                         effect_type_id = effect_type_id,
 112                         start_time = start_time,
 113                         time_left = duration,
 114                         hudids = hudids,
 115                         hudpos = free_hudpos,
 116                         }
 117
 118         playereffects.effects[effect_id] = effect
 119
 120         playereffects.effect_types[effect_type_id].apply(player)
 121         minetest.log("action", "[playereffects] Effect type "..effect_type_id.." applied to player "..playername.."!")
 122         minetest.after(duration, function(effect_id) playereffects.cancel_effect(effect_id) end, effect_id)
 123 end
 124
 125 function playereffects.cancel_effect_type(effect_type_id, cancel_all, playername)
 126         local effects = playereffects.get_player_effects(playername)
 127         if(cancel_all==nil) then all = false end
 128         for e=1, #effects do
 129                 if(effects[e].effect_type_id == effect_type_id) then
 130                         playereffects.cancel_effect(effects[e].effect_id)
 131                         if(cancel_all==false) then
 132                                 return
 133                         end
 134                 end
 135         end
 136 end
 137
 138 function playereffects.cancel_effect_group(groupname, playername)
 139         local effects = playereffects.get_player_effects(playername)
 140         for e=1,#effects do
 141                 local effect = effects[e]
 142                 local thesegroups = playereffects.effect_types[effect.effect_type_id].groups
 143                 local delete = false
 144                 for g=1,#thesegroups do
 145                         if(thesegroups[g] == groupname) then
 146                                 playereffects.cancel_effect(effect.effect_id)
 147                                 break
 148                         end
 149                 end
 150         end
 151 end
 152
 153 function playereffects.cancel_effect(effect_id)
 154         local effect = playereffects.effects[effect_id]
 155         if(effect ~= nil) then
 156                 local player = minetest.get_player_by_name(effect.playername)
 157                 if(effect.hudids.text_id~=nil) then
 158                         player:hud_remove(effect.hudids.text_id)
 159                 end
 160                 if(effect.hudids.icon_id~=nil) then
 161                         player:hud_remove(effect.hudids.icon_id)
 162                 end
 163                 playereffects.effect_types[effect.effect_type_id].cancel(effect)
 164                 playereffects.effects[effect_id] = nil
 165                 minetest.log("action", "[playereffects] Effect type "..effect.effect_type_id.." cancelled from player "..effect.playername.."!")
 166         end
 167 end
 168
 169 function playereffects.get_player_effects(playername)
 170         if(minetest.get_player_by_name(playername) ~= nil) then
 171                 local effects = {}
 172                 for k,v in pairs(playereffects.effects) do
 173                         if(v.playername == playername) then
 174                                 table.insert(effects, v)
 175                         end
 176                 end
 177                 return effects
 178         else
 179                 return {}
 180         end
 181 end
 182
 183 --[=[ Saving all data to file ]=]
 184 function playereffects.save_to_file()
 185         local save_time = os.time()
 186         local savetable = {}
 187         local inactive_effects = {}
 188         for id,effecttable in pairs(playereffects.inactive_effects) do
 189                 local playername = id
 190                 if(inactive_effects[playername] == nil) then
 191                         inactive_effects[playername] = {}
 192                 end
 193                 for i=1,#effecttable do
 194                         table.insert(inactive_effects[playername], effecttable[i])
 195                 end
 196         end
 197         for id,effect in pairs(playereffects.effects) do
 198                 local new_duration = effect.time_left - os.difftime(save_time, effect.start_time)
 199                 local new_effect = {
 200                         effect_id = effect.effect_id,
 201                         effect_type_id = effect.effect_type_id,
 202                         time_left = new_duration,
 203                         start_time = effect.start_time,
 204                         playername = effect.playername,
 205                 }
 206                 if(inactive_effects[effect.playername] == nil) then
 207                         inactive_effects[effect.playername] = {}
 208                 end
 209                 table.insert(inactive_effects[effect.playername], new_effect)
 210         end
 211
 212         savetable.inactive_effects = inactive_effects
 213         savetable.last_effect_id = playereffects.last_effect_id
 214
 215         local savestring = minetest.serialize(savetable)
 216
 217         local filepath = minetest.get_worldpath().."/playereffects.mt"
 218         local file = io.open(filepath, "w")
 219         if file then
 220                 file:write(savestring)
 221                 io.close(file)
 222                 minetest.log("action", "[playereffects] Wrote playereffects data into "..filepath..".")
 223         else
 224                 minetest.log("error", "[playereffects] Failed to write playereffects data into "..filepath..".")
 225         end
 226 end
 227
 228 --[=[ Callbacks ]=]
 229 --[[ Cancel all effects on player death ]]
 230 minetest.register_on_dieplayer(function(player)
 231         local effects = playereffects.get_player_effects(player:get_player_name())
 232         for e=1,#effects do
 233                 playereffects.cancel_effect(effects[e].effect_id)
 234         end
 235 end)
 236
 237
 238 minetest.register_on_leaveplayer(function(player)
 239         local leave_time = os.time()
 240         local playername = player:get_player_name()
 241         local effects = playereffects.get_player_effects(playername)
 242
 243         playereffects.hud_clear(player)
 244
 245         if(playereffects.inactive_effects[playername] == nil) then
 246                 playereffects.inactive_effects[playername] = {}
 247         end
 248         for e=1,#effects do
 249                 local new_duration = effects[e].time_left - os.difftime(leave_time, effects[e].start_time)
 250                 local new_effect = effects[e]
 251                 new_effect.time_left = new_duration
 252                 table.insert(playereffects.inactive_effects[playername], new_effect)
 253                 playereffects.cancel_effect(effects[e].effect_id)
 254         end
 255 end)
 256
 257 minetest.register_on_shutdown(function()
 258         minetest.log("action", "[playereffects] Server shuts down. Rescuing data into playereffects.mt")
 259         playereffects.save_to_file()
 260 end)
 261
 262 minetest.register_on_joinplayer(function(player)
 263         local playername = player:get_player_name()
 264
 265         -- load all the effects again (if any)
 266         if(playereffects.inactive_effects[playername] ~= nil) then
 267                 for i=1,#playereffects.inactive_effects[playername] do
 268                         local effect = playereffects.inactive_effects[playername][i]
 269                         playereffects.apply_effect_type(effect.effect_type_id, effect.time_left, player)
 270                 end
 271                 playereffects.inactive_effects[playername] = nil
 272         end
 273 end)
 274
 275 playereffects.globalstep_timer = 0
 276 playereffects.autosave_timer = 0
 277 minetest.register_globalstep(function(dtime)
 278         playereffects.globalstep_timer = playereffects.globalstep_timer + dtime
 279         playereffects.autosave_timer = playereffects.autosave_timer + dtime
 280         -- Update HUDs of all players
 281         if(playereffects.globalstep_timer >= 1) then
 282                 playereffects.globalstep_timer = 0
 283
 284                 local players = minetest.get_connected_players()
 285                 for p=1,#players do
 286                         playereffects.hud_update(players[p])
 287                 end
 288         end
 289         -- Autosave into file
 290         if(playereffects.use_autosave == true and playereffects.autosave_timer >= playereffects.autosave_time) then
 291                 playereffects.autosave_timer = 0
 292                 minetest.log("action", "[playereffects] Autosaving mod data to playereffects.mt ...")
 293                 playereffects.save_to_file()
 294         end
 295 end)
 296
 297
 298
 299
 300 --[=[ HUD ]=]
 301 function playereffects.hud_update(player)
 302         if(playereffects.use_hud == true) then
 303                 local now = os.time()
 304                 local effects = playereffects.get_player_effects(player:get_player_name())
 305                 for e=1,#effects do
 306                         local effect = effects[e]
 307                         if(effect.hudids.text_id ~= nil) then
 308                                 local description = playereffects.effect_types[effect.effect_type_id].description
 309                                 local time_left = os.difftime(effect.start_time + effect.time_left, now)
 310                                 player:hud_change(effect.hudids.text_id, "text", description .. " ("..tostring(time_left).." s)")
 311                         end
 312                 end
 313         end
 314 end
 315
 316 function playereffects.hud_clear(player)
 317         if(playereffects.use_hud == true) then
 318                 local playername = player:get_player_name()
 319                 local effects = playereffects.get_player_effects(playername)
 320                 if(effects ~= nil) then
 321                         for e=1,#effects do
 322                                 if(effects[e].hudids.text_id ~= nil) then
 323                                         player:hud_remove(effects[e].hudids.text_id)
 324                                 end
 325                                 if(effects[e].hudids.icon_id ~= nil) then
 326                                         player:hud_remove(effects[e].hudids.icon_id)
 327                                 end
 328                         end
 329                 end
 330         end
 331 end
 332
 333 function playereffects.hud_effect(effect_type_id, player, pos, time_left)
 334         local text_id, icon_id
 335         local effect_type = playereffects.effect_types[effect_type_id]
 336         if(playereffects.use_hud == true and effect_type.hidden == false) then
 337                 text_id = player:hud_add({
 338                         hud_elem_type = "text",
 339                         position = { x = 1, y = 0.3 },
 340                         name = "effect_"..effect_type_id,
 341                         text = playereffects.effect_types[effect_type_id].description .. " ("..tostring(time_left).." s)",
 342                         scale = { x = 170, y = 20},
 343                         alignment = { x = -1, y = 0 },
 344                         direction = 1,
 345                         number = 0xFFFFFF,
 346                         offset = { x = -5, y = pos*20 }
 347                 })
 348                 if(playereffects.effect_types[effect_type_id].icon ~= nil) then
 349                         icon_id = player:hud_add({
 350                                 hud_elem_type = "image",
 351                                 scale = { x = 1, y = 1 },
 352                                 position = { x = 1, y = 0.3 },
 353                                 name = "effect_icon_"..effect_type_id,
 354                                 text = playereffects.effect_types[effect_type_id].icon,
 355                                 alignment = { x = -1, y=0 },
 356                                 direction = 0,
 357                                 offset = { x = -186, y = pos*20 },
 358                         })
 359                 end
 360         else
 361                 text_id = nil
 362                 icon_id = nil
 363         end
 364         return { text_id = text_id, icon_id = icon_id }
 365 end
 366
 367
 368 -- LOAD EXAMPLES
 369 dofile(minetest.get_modpath(minetest.get_current_modname()).."/examples.lua")