function ctf_classes.register(cname, def) assert(not ctf_classes.__classes[cname]) def.name = cname ctf_classes.__classes[cname] = def table.insert(ctf_classes.__classes_ordered, def) def.pros = def.pros or {} def.cons = def.cons or {} def.properties = def.properties or {} if def.properties.can_capture == nil then def.properties.can_capture = true end def.properties.initial_stuff = def.properties.initial_stuff or {} if not def.properties.item_blacklist then def.properties.item_blacklist = {} for i, item in ipairs(def.properties.initial_stuff) do local iname = ItemStack(item):get_name() -- Only add to item blacklist if not in the whitelist if table.indexof(def.properties.item_whitelist or {}, iname) == -1 then def.properties.item_blacklist[i] = iname end end end if def.properties.additional_item_blacklist then for i=1, #def.properties.additional_item_blacklist do table.insert(def.properties.item_blacklist, def.properties.additional_item_blacklist[i]) end end -- Validate items for i=1, #def.properties.initial_stuff do local item_name = ItemStack(def.properties.initial_stuff[i]):get_name() assert(minetest.registered_items[item_name], "Item " .. item_name .. " not found") end for i=1, #def.properties.item_blacklist do local item_name = def.properties.item_blacklist[i] assert(minetest.registered_items[item_name], "Item " .. item_name .. " not found") end def.properties.speed = def.properties.speed or 1 def.properties.max_hp = def.properties.max_hp or 20 end local registered_on_changed = {} function ctf_classes.register_on_changed(func) table.insert(registered_on_changed, func) end function ctf_classes.set_skin(player, color, class) player:set_properties({ textures = {"ctf_classes_skin_" .. class.name .. "_" .. (color or "blue") .. ".png"} }) end function ctf_classes.get(player) if type(player) == "string" then player = minetest.get_player_by_name(player) end -- Return class from player meta if valid, or default class local cname = player:get_meta():get("ctf_classes:class") if not ctf_classes.__classes[cname] then cname = ctf_classes.default_class end return ctf_classes.__classes[cname] end function ctf_classes.set(player, new_name) assert(type(new_name) == "string") local new = ctf_classes.__classes[new_name] assert(new) local meta = player:get_meta() local old_name = meta:get("ctf_classes:class") meta:set_string("ctf_classes:class", new_name) ctf_classes.update(player) ctf_classes.set_cooldown(player:get_player_name()) if old_name == nil or old_name ~= new_name then local old = old_name and ctf_classes.__classes[old_name] for i=1, #registered_on_changed do registered_on_changed[i](player, old, new) end end end local function set_max_hp(player, max_hp) local cur_hp = player:get_hp() local old_max = player:get_properties().hp_max local new_hp = cur_hp + max_hp - old_max player:set_properties({ hp_max = max_hp }) if new_hp > max_hp then minetest.log("error", string.format("New hp %d is larger than new max %d, old max is %d", new_hp, max_hp, old_max)) new_hp = max_hp end if cur_hp > max_hp then player:set_hp(max_hp) elseif new_hp > cur_hp then player:set_hp(new_hp) end end function ctf_classes.update(player) local name = player:get_player_name() local class = ctf_classes.get(player) local color = ctf_colors.get_color(ctf.player(name)).text set_max_hp(player, class.properties.max_hp) ctf_classes.set_skin(player, color, class) physics.set(player:get_player_name(), "ctf_classes:physics", { speed = class.properties.speed, jump = class.properties.jump, gravity = class.properties.gravity, }) crafting.lock_all(player:get_player_name()) for i=1, #(class.properties.crafting or {}) do crafting.unlock(player:get_player_name(), class.properties.crafting[i]) end end local function sqdist(a, b) local x = a.x - b.x local y = a.y - b.y local z = a.z - b.z return x*x + y*y + z*z end function ctf_classes.get_flag_pos(player) local tplayer = ctf.player(player:get_player_name()) if not tplayer or not tplayer.team then return nil end local team = ctf.team(tplayer.team) if team and team.flags[1] then return vector.new(team.flags[1]) end return nil end function ctf_classes.can_change(player) if minetest.check_player_privs(player, "ctf_admin") then return true end if ctf_classes.get_cooldown(player:get_player_name()) then return false, "You need to wait to change classes again!" end local flag_pos = ctf_classes.get_flag_pos(player) if flag_pos then return sqdist(player:get_pos(), flag_pos) < 25, "Move closer to the flag to change classes!" end return false, "Flag does not exist!" end -- Cooldown time to prevent consumables abuse by changing to a class and back local COOLDOWN_TIME = 30 local cooldown = {} function ctf_classes.get_cooldown(name) return cooldown[name] end function ctf_classes.set_cooldown(name) cooldown[name] = true minetest.after(COOLDOWN_TIME, function() cooldown[name] = nil end) end minetest.register_on_dieplayer(function(player) cooldown[player:get_player_name()] = nil end)