init.lua

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