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 --      minetest.log("action", "[playereffects] Effect type "..effect_type_id.." applied to player "..playername.." (effect_id = "..effect_id..").")
 196         if(repeat_interval ~= nil) then
 197                 minetest.after(repeat_interval_time_left, playereffects.repeater, effect_id, duration, player, playereffects.effect_types[effect_type_id].apply)
 198         else
 199                 minetest.after(duration, function(effect_id) playereffects.cancel_effect(effect_id) end, effect_id)
 200         end
 201
 202         return effect_id
 203 end
 204
 205 function playereffects.repeater(effect_id, repetitions, player, apply)
 206         local effect = playereffects.effects[effect_id]
 207         if(effect ~= nil) then
 208                 local repetitions = effect.time_left
 209                 apply(player)
 210                 repetitions = repetitions - 1
 211                 effect.time_left = repetitions
 212                 if(repetitions <= 0) then
 213                         playereffects.cancel_effect(effect_id)
 214                 else
 215                         local repeat_interval = playereffects.effect_types[effect.effect_type_id].repeat_interval
 216                         effect.repeat_interval_time_left = repeat_interval
 217                         effect.repeat_interval_start_time = os.time()
 218                         minetest.after(
 219                                 repeat_interval,
 220                                 playereffects.repeater,
 221                                 effect_id,
 222                                 repetitions,
 223                                 player,
 224                                 apply
 225                         )
 226                 end
 227         end
 228 end
 229
 230 function playereffects.cancel_effect_type(effect_type_id, cancel_all, playername)
 231         local effects = playereffects.get_player_effects(playername)
 232         if(cancel_all==nil) then all = false end
 233         for e=1, #effects do
 234                 if(effects[e].effect_type_id == effect_type_id) then
 235                         playereffects.cancel_effect(effects[e].effect_id)
 236                         if(cancel_all==false) then
 237                                 return
 238                         end
 239                 end
 240         end
 241 end
 242
 243 function playereffects.cancel_effect_group(groupname, playername)
 244         local effects = playereffects.get_player_effects(playername)
 245         for e=1,#effects do
 246                 local effect = effects[e]
 247                 local thesegroups = playereffects.effect_types[effect.effect_type_id].groups
 248                 local delete = false
 249                 for g=1,#thesegroups do
 250                         if(thesegroups[g] == groupname) then
 251                                 playereffects.cancel_effect(effect.effect_id)
 252                                 break
 253                         end
 254                 end
 255         end
 256 end
 257
 258 function playereffects.get_remaining_effect_time(effect_id)
 259         local now = os.time()
 260         local effect = playereffects.effects[effect_id]
 261         if(effect ~= nil) then
 262                 return (effect.time_left - os.difftime(now, effect.start_time))
 263         else
 264                 return nil
 265         end
 266 end
 267
 268 function playereffects.cancel_effect(effect_id)
 269         local effect = playereffects.effects[effect_id]
 270         if(effect ~= nil) then
 271                 local player = minetest.get_player_by_name(effect.playername)
 272                 local hudinfo = playereffects.hudinfos[effect.playername][effect_id]
 273                 if(hudinfo ~= nil) then
 274                         if(hudinfo.text_id~=nil) then
 275                                 player:hud_remove(hudinfo.text_id)
 276                         end
 277                         if(hudinfo.icon_id~=nil) then
 278                                 player:hud_remove(hudinfo.icon_id)
 279                         end
 280                         playereffects.hudinfos[effect.playername][effect_id] = nil
 281                 end
 282                 playereffects.effect_types[effect.effect_type_id].cancel(effect, player)
 283                 playereffects.effects[effect_id] = nil
 284 --              minetest.log("action", "[playereffects] Effect type "..effect.effect_type_id.." cancelled from player "..effect.playername.."!")
 285         end
 286 end
 287
 288 function playereffects.get_player_effects(playername)
 289         if(minetest.get_player_by_name(playername) ~= nil) then
 290                 local effects = {}
 291                 for k,v in pairs(playereffects.effects) do
 292                         if(v.playername == playername) then
 293                                 table.insert(effects, v)
 294                         end
 295                 end
 296                 return effects
 297         else
 298                 return {}
 299         end
 300 end
 301
 302 --[=[ Saving all data to file ]=]
 303 function playereffects.save_to_file()
 304         local save_time = os.time()
 305         local savetable = {}
 306         local inactive_effects = {}
 307         for id,effecttable in pairs(playereffects.inactive_effects) do
 308                 local playername = id
 309                 if(inactive_effects[playername] == nil) then
 310                         inactive_effects[playername] = {}
 311                 end
 312                 for i=1,#effecttable do
 313                         table.insert(inactive_effects[playername], effecttable[i])
 314                 end
 315         end
 316         for id,effect in pairs(playereffects.effects) do
 317                 local new_duration, new_repeat_duration
 318                 if(playereffects.effect_types[effect.effect_type_id].repeat_interval ~= nil) then
 319                         new_duration = effect.time_left
 320                         new_repeat_duration = effect.repeat_interval_time_left - os.difftime(save_time, effect.repeat_interval_start_time)
 321                 else
 322                         new_duration = effect.time_left - os.difftime(save_time, effect.start_time)
 323                 end
 324                 local new_effect = {
 325                         effect_id = effect.effect_id,
 326                         effect_type_id = effect.effect_type_id,
 327                         time_left = new_duration,
 328                         repeat_interval_time_left = new_repeat_duration,
 329                         start_time = effect.start_time,
 330                         repeat_interval_start_time = effect.repeat_interval_start_time,
 331                         playername = effect.playername,
 332                         metadata = effect.metadata
 333                 }
 334                 if(inactive_effects[effect.playername] == nil) then
 335                         inactive_effects[effect.playername] = {}
 336                 end
 337                 table.insert(inactive_effects[effect.playername], new_effect)
 338         end
 339
 340         savetable.inactive_effects = inactive_effects
 341         savetable.last_effect_id = playereffects.last_effect_id
 342
 343         local savestring = minetest.serialize(savetable)
 344
 345         local filepath = minetest.get_worldpath().."/playereffects.mt"
 346         local file = io.open(filepath, "w")
 347         if file then
 348                 file:write(savestring)
 349                 io.close(file)
 350                 minetest.log("action", "[playereffects] Wrote playereffects data into "..filepath..".")
 351         else
 352                 minetest.log("error", "[playereffects] Failed to write playereffects data into "..filepath..".")
 353         end
 354 end
 355
 356 --[=[ Callbacks ]=]
 357 --[[ Cancel all effects on player death ]]
 358 minetest.register_on_dieplayer(function(player)
 359         local effects = playereffects.get_player_effects(player:get_player_name())
 360         for e=1,#effects do
 361                 if(playereffects.effect_types[effects[e].effect_type_id].cancel_on_death == true) then
 362                         playereffects.cancel_effect(effects[e].effect_id)
 363                 end
 364         end
 365 end)
 366
 367
 368 minetest.register_on_leaveplayer(function(player)
 369         local leave_time = os.time()
 370         local playername = player:get_player_name()
 371         local effects = playereffects.get_player_effects(playername)
 372
 373         playereffects.hud_clear(player)
 374
 375         if(playereffects.inactive_effects[playername] == nil) then
 376                 playereffects.inactive_effects[playername] = {}
 377         end
 378         for e=1,#effects do
 379                 local new_duration = effects[e].time_left - os.difftime(leave_time, effects[e].start_time)
 380                 local new_effect = effects[e]
 381                 new_effect.time_left = new_duration
 382                 table.insert(playereffects.inactive_effects[playername], new_effect)
 383                 playereffects.cancel_effect(effects[e].effect_id)
 384         end
 385 end)
 386
 387 minetest.register_on_shutdown(function()
 388         minetest.log("action", "[playereffects] Server shuts down. Rescuing data into playereffects.mt")
 389         playereffects.save_to_file()
 390 end)
 391
 392 minetest.register_on_joinplayer(function(player)
 393         local playername = player:get_player_name()
 394
 395         -- load all the effects again (if any)
 396         if(playereffects.inactive_effects[playername] ~= nil) then
 397                 for i=1,#playereffects.inactive_effects[playername] do
 398                         local effect = playereffects.inactive_effects[playername][i]
 399                         playereffects.apply_effect_type(effect.effect_type_id, effect.time_left, player, effect.repeat_interval_time_left)
 400                 end
 401                 playereffects.inactive_effects[playername] = nil
 402         end
 403 end)
 404
 405 playereffects.globalstep_timer = 0
 406 playereffects.autosave_timer = 0
 407 minetest.register_globalstep(function(dtime)
 408         playereffects.globalstep_timer = playereffects.globalstep_timer + dtime
 409         playereffects.autosave_timer = playereffects.autosave_timer + dtime
 410         -- Update HUDs of all players
 411         if(playereffects.globalstep_timer >= 1) then
 412                 playereffects.globalstep_timer = 0
 413
 414                 local players = minetest.get_connected_players()
 415                 for p=1,#players do
 416                         playereffects.hud_update(players[p])
 417                 end
 418         end
 419         -- Autosave into file
 420         if(playereffects.use_autosave == true and playereffects.autosave_timer >= playereffects.autosave_time) then
 421                 playereffects.autosave_timer = 0
 422                 minetest.log("action", "[playereffects] Autosaving mod data to playereffects.mt ...")
 423                 playereffects.save_to_file()
 424         end
 425 end)
 426
 427
 428
 429
 430 --[=[ HUD ]=]
 431 function playereffects.hud_update(player)
 432         if(playereffects.use_hud == true) then
 433                 local now = os.time()
 434                 local playername = player:get_player_name()
 435                 local hudinfos = playereffects.hudinfos[playername]
 436                 if(hudinfos ~= nil) then
 437                         for effect_id, hudinfo in pairs(hudinfos) do
 438                                 local effect = playereffects.effects[effect_id]
 439                                 if(effect ~= nil and hudinfo.text_id ~= nil) then
 440                                         local description = playereffects.effect_types[effect.effect_type_id].description
 441                                         local repeat_interval = playereffects.effect_types[effect.effect_type_id].repeat_interval
 442                                         if(repeat_interval ~= nil) then
 443                                                 local repeat_interval_time_left = os.difftime(effect.repeat_interval_start_time + effect.repeat_interval_time_left, now)
 444                                                 player:hud_change(hudinfo.text_id, "text", description .. " ("..tostring(effect.time_left).."/"..tostring(repeat_interval_time_left) .. "s )")
 445                                         else
 446                                                 local time_left = os.difftime(effect.start_time + effect.time_left, now)
 447                                                 player:hud_change(hudinfo.text_id, "text", description .. " ("..tostring(time_left).." s)")
 448                                         end
 449                                 end
 450                         end
 451                 end
 452         end
 453 end
 454
 455 function playereffects.hud_clear(player)
 456         if(playereffects.use_hud == true) then
 457                 local playername = player:get_player_name()
 458                 local hudinfos = playereffects.hudinfos[playername]
 459                 if(hudinfos ~= nil) then
 460                         for effect_id, hudinfo in pairs(hudinfos) do
 461                                 local effect = playereffects.effects[effect_id]
 462                                 if(hudinfo.text_id ~= nil) then
 463                                         player:hud_remove(hudinfo.text_id)
 464                                 end
 465                                 if(hudinfo.icon_id ~= nil) then
 466                                         player:hud_remove(hudinfo.icon_id)
 467                                 end
 468                                 playereffects.hudinfos[playername][effect_id] = nil
 469                         end
 470                 end
 471         end
 472 end
 473
 474 function playereffects.hud_effect(effect_type_id, player, pos, time_left, repeat_interval_time_left)
 475         local text_id, icon_id
 476         local effect_type = playereffects.effect_types[effect_type_id]
 477         if(playereffects.use_hud == true and effect_type.hidden == false) then
 478                 local color
 479                 if(playereffects.effect_types[effect_type_id].cancel_on_death == true) then
 480                         color = 0xFFFFFF
 481                 else
 482                         color = 0xF0BAFF
 483                 end
 484                 local description = playereffects.effect_types[effect_type_id].description
 485                 if(repeat_interval_time_left ~= nil) then
 486                         text =  description .. " ("..tostring(time_left).."/"..tostring(repeat_interval_time_left) .. "s )"
 487                 else
 488                         text = description .. " ("..tostring(time_left).." s)"
 489                 end
 490                 text_id = player:hud_add({
 491                         hud_elem_type = "text",
 492                         position = { x = 1, y = 0.3 },
 493                         name = "effect_"..effect_type_id,
 494                         text = text,
 495                         scale = { x = 170, y = 20},
 496                         alignment = { x = -1, y = 0 },
 497                         direction = 1,
 498                         number = color,
 499                         offset = { x = -5, y = pos*20 }
 500                 })
 501                 if(playereffects.effect_types[effect_type_id].icon ~= nil) then
 502                         icon_id = player:hud_add({
 503                                 hud_elem_type = "image",
 504                                 scale = { x = 1, y = 1 },
 505                                 position = { x = 1, y = 0.3 },
 506                                 name = "effect_icon_"..effect_type_id,
 507                                 text = playereffects.effect_types[effect_type_id].icon,
 508                                 alignment = { x = -1, y=0 },
 509                                 direction = 0,
 510                                 offset = { x = -186, y = pos*20 },
 511                         })
 512                 end
 513         else
 514                 text_id = nil
 515                 icon_id = nil
 516         end
 517         return text_id, icon_id
 518 end
 519
 520
 521 -- LOAD EXAMPLES
 522 if(playereffects.use_examples == true) then
 523         dofile(minetest.get_modpath(minetest.get_current_modname()).."/examples.lua")
 524 end