mirror of
https://github.com/minetest/minetest.git
synced 2024-12-04 21:43:44 +01:00
480d5f2d51
Fixes #12219
885 lines
22 KiB
Lua
885 lines
22 KiB
Lua
--Minetest
|
|
--Copyright (C) 2013 sapier
|
|
--
|
|
--This program is free software; you can redistribute it and/or modify
|
|
--it under the terms of the GNU Lesser General Public License as published by
|
|
--the Free Software Foundation; either version 2.1 of the License, or
|
|
--(at your option) any later version.
|
|
--
|
|
--This program is distributed in the hope that it will be useful,
|
|
--but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
--MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
--GNU Lesser General Public License for more details.
|
|
--
|
|
--You should have received a copy of the GNU Lesser General Public License along
|
|
--with this program; if not, write to the Free Software Foundation, Inc.,
|
|
--51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
--------------------------------------------------------------------------------
|
|
local function get_last_folder(text,count)
|
|
local parts = text:split(DIR_DELIM)
|
|
|
|
if count == nil then
|
|
return parts[#parts]
|
|
end
|
|
|
|
local retval = ""
|
|
for i=1,count,1 do
|
|
retval = retval .. parts[#parts - (count-i)] .. DIR_DELIM
|
|
end
|
|
|
|
return retval
|
|
end
|
|
|
|
local function cleanup_path(temppath)
|
|
|
|
local parts = temppath:split("-")
|
|
temppath = ""
|
|
for i=1,#parts,1 do
|
|
if temppath ~= "" then
|
|
temppath = temppath .. "_"
|
|
end
|
|
temppath = temppath .. parts[i]
|
|
end
|
|
|
|
parts = temppath:split(".")
|
|
temppath = ""
|
|
for i=1,#parts,1 do
|
|
if temppath ~= "" then
|
|
temppath = temppath .. "_"
|
|
end
|
|
temppath = temppath .. parts[i]
|
|
end
|
|
|
|
parts = temppath:split("'")
|
|
temppath = ""
|
|
for i=1,#parts,1 do
|
|
if temppath ~= "" then
|
|
temppath = temppath .. ""
|
|
end
|
|
temppath = temppath .. parts[i]
|
|
end
|
|
|
|
parts = temppath:split(" ")
|
|
temppath = ""
|
|
for i=1,#parts,1 do
|
|
if temppath ~= "" then
|
|
temppath = temppath
|
|
end
|
|
temppath = temppath .. parts[i]
|
|
end
|
|
|
|
return temppath
|
|
end
|
|
|
|
local function load_texture_packs(txtpath, retval)
|
|
local list = core.get_dir_list(txtpath, true)
|
|
local current_texture_path = core.settings:get("texture_path")
|
|
|
|
for _, item in ipairs(list) do
|
|
if item ~= "base" then
|
|
local path = txtpath .. DIR_DELIM .. item .. DIR_DELIM
|
|
local conf = Settings(path .. "texture_pack.conf")
|
|
local enabled = path == current_texture_path
|
|
|
|
local title = conf:get("title")
|
|
-- list_* is only used if non-nil, else the regular versions are used.
|
|
|
|
retval[#retval + 1] = {
|
|
name = item,
|
|
title = title,
|
|
list_name = enabled and fgettext("$1 (Enabled)", item) or nil,
|
|
list_title = enabled and fgettext("$1 (Enabled)", title) or nil,
|
|
author = conf:get("author"),
|
|
release = tonumber(conf:get("release")) or 0,
|
|
type = "txp",
|
|
path = path,
|
|
enabled = enabled,
|
|
}
|
|
end
|
|
end
|
|
end
|
|
|
|
function get_mods(path, virtual_path, retval, modpack)
|
|
local mods = core.get_dir_list(path, true)
|
|
|
|
for _, name in ipairs(mods) do
|
|
if name:sub(1, 1) ~= "." then
|
|
local mod_path = path .. DIR_DELIM .. name
|
|
local mod_virtual_path = virtual_path .. "/" .. name
|
|
local toadd = {
|
|
dir_name = name,
|
|
parent_dir = path,
|
|
}
|
|
retval[#retval + 1] = toadd
|
|
|
|
-- Get config file
|
|
local mod_conf
|
|
local modpack_conf = io.open(mod_path .. DIR_DELIM .. "modpack.conf")
|
|
if modpack_conf then
|
|
toadd.is_modpack = true
|
|
modpack_conf:close()
|
|
|
|
mod_conf = Settings(mod_path .. DIR_DELIM .. "modpack.conf"):to_table()
|
|
if mod_conf.name then
|
|
name = mod_conf.name
|
|
toadd.is_name_explicit = true
|
|
end
|
|
else
|
|
mod_conf = Settings(mod_path .. DIR_DELIM .. "mod.conf"):to_table()
|
|
if mod_conf.name then
|
|
name = mod_conf.name
|
|
toadd.is_name_explicit = true
|
|
end
|
|
end
|
|
|
|
-- Read from config
|
|
toadd.name = name
|
|
toadd.title = mod_conf.title
|
|
toadd.author = mod_conf.author
|
|
toadd.release = tonumber(mod_conf.release) or 0
|
|
toadd.path = mod_path
|
|
toadd.virtual_path = mod_virtual_path
|
|
toadd.type = "mod"
|
|
|
|
-- Check modpack.txt
|
|
-- Note: modpack.conf is already checked above
|
|
local modpackfile = io.open(mod_path .. DIR_DELIM .. "modpack.txt")
|
|
if modpackfile then
|
|
modpackfile:close()
|
|
toadd.is_modpack = true
|
|
end
|
|
|
|
-- Deal with modpack contents
|
|
if modpack and modpack ~= "" then
|
|
toadd.modpack = modpack
|
|
elseif toadd.is_modpack then
|
|
toadd.type = "modpack"
|
|
toadd.is_modpack = true
|
|
get_mods(mod_path, mod_virtual_path, retval, name)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
--modmanager implementation
|
|
pkgmgr = {}
|
|
|
|
function pkgmgr.get_texture_packs()
|
|
local txtpath = core.get_texturepath()
|
|
local txtpath_system = core.get_texturepath_share()
|
|
local retval = {}
|
|
|
|
load_texture_packs(txtpath, retval)
|
|
-- on portable versions these two paths coincide. It avoids loading the path twice
|
|
if txtpath ~= txtpath_system then
|
|
load_texture_packs(txtpath_system, retval)
|
|
end
|
|
|
|
table.sort(retval, function(a, b)
|
|
return a.name > b.name
|
|
end)
|
|
|
|
return retval
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function pkgmgr.get_folder_type(path)
|
|
local testfile = io.open(path .. DIR_DELIM .. "init.lua","r")
|
|
if testfile ~= nil then
|
|
testfile:close()
|
|
return { type = "mod", path = path }
|
|
end
|
|
|
|
testfile = io.open(path .. DIR_DELIM .. "modpack.conf","r")
|
|
if testfile ~= nil then
|
|
testfile:close()
|
|
return { type = "modpack", path = path }
|
|
end
|
|
|
|
testfile = io.open(path .. DIR_DELIM .. "modpack.txt","r")
|
|
if testfile ~= nil then
|
|
testfile:close()
|
|
return { type = "modpack", path = path }
|
|
end
|
|
|
|
testfile = io.open(path .. DIR_DELIM .. "game.conf","r")
|
|
if testfile ~= nil then
|
|
testfile:close()
|
|
return { type = "game", path = path }
|
|
end
|
|
|
|
testfile = io.open(path .. DIR_DELIM .. "texture_pack.conf","r")
|
|
if testfile ~= nil then
|
|
testfile:close()
|
|
return { type = "txp", path = path }
|
|
end
|
|
|
|
return nil
|
|
end
|
|
|
|
-------------------------------------------------------------------------------
|
|
function pkgmgr.get_base_folder(temppath)
|
|
if temppath == nil then
|
|
return { type = "invalid", path = "" }
|
|
end
|
|
|
|
local ret = pkgmgr.get_folder_type(temppath)
|
|
if ret then
|
|
return ret
|
|
end
|
|
|
|
local subdirs = core.get_dir_list(temppath, true)
|
|
if #subdirs == 1 then
|
|
ret = pkgmgr.get_folder_type(temppath .. DIR_DELIM .. subdirs[1])
|
|
if ret then
|
|
return ret
|
|
else
|
|
return { type = "invalid", path = temppath .. DIR_DELIM .. subdirs[1] }
|
|
end
|
|
end
|
|
|
|
return nil
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function pkgmgr.isValidModname(modpath)
|
|
if modpath:find("-") ~= nil then
|
|
return false
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function pkgmgr.parse_register_line(line)
|
|
local pos1 = line:find("\"")
|
|
local pos2 = nil
|
|
if pos1 ~= nil then
|
|
pos2 = line:find("\"",pos1+1)
|
|
end
|
|
|
|
if pos1 ~= nil and pos2 ~= nil then
|
|
local item = line:sub(pos1+1,pos2-1)
|
|
|
|
if item ~= nil and
|
|
item ~= "" then
|
|
local pos3 = item:find(":")
|
|
|
|
if pos3 ~= nil then
|
|
local retval = item:sub(1,pos3-1)
|
|
if retval ~= nil and
|
|
retval ~= "" then
|
|
return retval
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function pkgmgr.parse_dofile_line(modpath,line)
|
|
local pos1 = line:find("\"")
|
|
local pos2 = nil
|
|
if pos1 ~= nil then
|
|
pos2 = line:find("\"",pos1+1)
|
|
end
|
|
|
|
if pos1 ~= nil and pos2 ~= nil then
|
|
local filename = line:sub(pos1+1,pos2-1)
|
|
|
|
if filename ~= nil and
|
|
filename ~= "" and
|
|
filename:find(".lua") then
|
|
return pkgmgr.identify_modname(modpath,filename)
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function pkgmgr.identify_modname(modpath,filename)
|
|
local testfile = io.open(modpath .. DIR_DELIM .. filename,"r")
|
|
if testfile ~= nil then
|
|
local line = testfile:read()
|
|
|
|
while line~= nil do
|
|
local modname = nil
|
|
|
|
if line:find("minetest.register_tool") then
|
|
modname = pkgmgr.parse_register_line(line)
|
|
end
|
|
|
|
if line:find("minetest.register_craftitem") then
|
|
modname = pkgmgr.parse_register_line(line)
|
|
end
|
|
|
|
|
|
if line:find("minetest.register_node") then
|
|
modname = pkgmgr.parse_register_line(line)
|
|
end
|
|
|
|
if line:find("dofile") then
|
|
modname = pkgmgr.parse_dofile_line(modpath,line)
|
|
end
|
|
|
|
if modname ~= nil then
|
|
testfile:close()
|
|
return modname
|
|
end
|
|
|
|
line = testfile:read()
|
|
end
|
|
testfile:close()
|
|
end
|
|
|
|
return nil
|
|
end
|
|
--------------------------------------------------------------------------------
|
|
function pkgmgr.render_packagelist(render_list, use_technical_names)
|
|
if not render_list then
|
|
if not pkgmgr.global_mods then
|
|
pkgmgr.refresh_globals()
|
|
end
|
|
render_list = pkgmgr.global_mods
|
|
end
|
|
|
|
local list = render_list:get_list()
|
|
local retval = {}
|
|
for i, v in ipairs(list) do
|
|
local color = ""
|
|
if v.is_modpack then
|
|
local rawlist = render_list:get_raw_list()
|
|
color = mt_color_dark_green
|
|
|
|
for j = 1, #rawlist, 1 do
|
|
if rawlist[j].modpack == list[i].name and
|
|
not rawlist[j].enabled then
|
|
-- Modpack not entirely enabled so showing as grey
|
|
color = mt_color_grey
|
|
break
|
|
end
|
|
end
|
|
elseif v.is_game_content or v.type == "game" then
|
|
color = mt_color_blue
|
|
elseif v.enabled or v.type == "txp" then
|
|
color = mt_color_green
|
|
end
|
|
|
|
retval[#retval + 1] = color
|
|
if v.modpack ~= nil or v.loc == "game" then
|
|
retval[#retval + 1] = "1"
|
|
else
|
|
retval[#retval + 1] = "0"
|
|
end
|
|
|
|
if use_technical_names then
|
|
retval[#retval + 1] = core.formspec_escape(v.list_name or v.name)
|
|
else
|
|
retval[#retval + 1] = core.formspec_escape(v.list_title or v.list_name or v.title or v.name)
|
|
end
|
|
end
|
|
|
|
return table.concat(retval, ",")
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function pkgmgr.get_dependencies(path)
|
|
if path == nil then
|
|
return {}, {}
|
|
end
|
|
|
|
local info = core.get_content_info(path)
|
|
return info.depends or {}, info.optional_depends or {}
|
|
end
|
|
|
|
----------- tests whether all of the mods in the modpack are enabled -----------
|
|
function pkgmgr.is_modpack_entirely_enabled(data, name)
|
|
local rawlist = data.list:get_raw_list()
|
|
for j = 1, #rawlist do
|
|
if rawlist[j].modpack == name and not rawlist[j].enabled then
|
|
return false
|
|
end
|
|
end
|
|
return true
|
|
end
|
|
|
|
local function disable_all_by_name(list, name, except)
|
|
for i=1, #list do
|
|
if list[i].name == name and list[i] ~= except then
|
|
list[i].enabled = false
|
|
end
|
|
end
|
|
end
|
|
|
|
---------- toggles or en/disables a mod or modpack and its dependencies --------
|
|
local function toggle_mod_or_modpack(list, toggled_mods, enabled_mods, toset, mod)
|
|
if not mod.is_modpack then
|
|
-- Toggle or en/disable the mod
|
|
if toset == nil then
|
|
toset = not mod.enabled
|
|
end
|
|
if mod.enabled ~= toset then
|
|
toggled_mods[#toggled_mods+1] = mod.name
|
|
end
|
|
if toset then
|
|
-- Mark this mod for recursive dependency traversal
|
|
enabled_mods[mod.name] = true
|
|
|
|
-- Disable other mods with the same name
|
|
disable_all_by_name(list, mod.name, mod)
|
|
end
|
|
mod.enabled = toset
|
|
else
|
|
-- Toggle or en/disable every mod in the modpack,
|
|
-- interleaved unsupported
|
|
for i = 1, #list do
|
|
if list[i].modpack == mod.name then
|
|
toggle_mod_or_modpack(list, toggled_mods, enabled_mods, toset, list[i])
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function pkgmgr.enable_mod(this, toset)
|
|
local list = this.data.list:get_list()
|
|
local mod = list[this.data.selected_mod]
|
|
|
|
-- Game mods can't be enabled or disabled
|
|
if mod.is_game_content then
|
|
return
|
|
end
|
|
|
|
local toggled_mods = {}
|
|
local enabled_mods = {}
|
|
toggle_mod_or_modpack(list, toggled_mods, enabled_mods, toset, mod)
|
|
toset = mod.enabled -- Update if toggled
|
|
|
|
if not toset then
|
|
-- Mod(s) were disabled, so no dependencies need to be enabled
|
|
table.sort(toggled_mods)
|
|
core.log("info", "Following mods were disabled: " ..
|
|
table.concat(toggled_mods, ", "))
|
|
return
|
|
end
|
|
|
|
-- Enable mods' depends after activation
|
|
|
|
-- Make a list of mod ids indexed by their names
|
|
local mod_ids = {}
|
|
for id, mod2 in pairs(list) do
|
|
if mod2.type == "mod" and not mod2.is_modpack then
|
|
mod_ids[mod2.name] = id
|
|
end
|
|
end
|
|
|
|
-- to_enable is used as a DFS stack with sp as stack pointer
|
|
local to_enable = {}
|
|
local sp = 0
|
|
for name in pairs(enabled_mods) do
|
|
local depends = pkgmgr.get_dependencies(list[mod_ids[name]].path)
|
|
for i = 1, #depends do
|
|
local dependency_name = depends[i]
|
|
if not enabled_mods[dependency_name] then
|
|
sp = sp+1
|
|
to_enable[sp] = dependency_name
|
|
end
|
|
end
|
|
end
|
|
|
|
-- If sp is 0, every dependency is already activated
|
|
while sp > 0 do
|
|
local name = to_enable[sp]
|
|
sp = sp-1
|
|
|
|
if not enabled_mods[name] then
|
|
enabled_mods[name] = true
|
|
local mod_to_enable = list[mod_ids[name]]
|
|
if not mod_to_enable then
|
|
core.log("warning", "Mod dependency \"" .. name ..
|
|
"\" not found!")
|
|
else
|
|
if not mod_to_enable.enabled then
|
|
mod_to_enable.enabled = true
|
|
toggled_mods[#toggled_mods+1] = mod_to_enable.name
|
|
end
|
|
-- Push the dependencies of the dependency onto the stack
|
|
local depends = pkgmgr.get_dependencies(mod_to_enable.path)
|
|
for i = 1, #depends do
|
|
if not enabled_mods[name] then
|
|
sp = sp+1
|
|
to_enable[sp] = depends[i]
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Log the list of enabled mods
|
|
table.sort(toggled_mods)
|
|
core.log("info", "Following mods were enabled: " ..
|
|
table.concat(toggled_mods, ", "))
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function pkgmgr.get_worldconfig(worldpath)
|
|
local filename = worldpath ..
|
|
DIR_DELIM .. "world.mt"
|
|
|
|
local worldfile = Settings(filename)
|
|
|
|
local worldconfig = {}
|
|
worldconfig.global_mods = {}
|
|
worldconfig.game_mods = {}
|
|
|
|
for key,value in pairs(worldfile:to_table()) do
|
|
if key == "gameid" then
|
|
worldconfig.id = value
|
|
elseif key:sub(0, 9) == "load_mod_" then
|
|
-- Compatibility: Check against "nil" which was erroneously used
|
|
-- as value for fresh configured worlds
|
|
worldconfig.global_mods[key] = value ~= "false" and value ~= "nil"
|
|
and value
|
|
else
|
|
worldconfig[key] = value
|
|
end
|
|
end
|
|
|
|
--read gamemods
|
|
local gamespec = pkgmgr.find_by_gameid(worldconfig.id)
|
|
pkgmgr.get_game_mods(gamespec, worldconfig.game_mods)
|
|
|
|
return worldconfig
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function pkgmgr.install_dir(type, path, basename, targetpath)
|
|
local basefolder = pkgmgr.get_base_folder(path)
|
|
|
|
-- There's no good way to detect a texture pack, so let's just assume
|
|
-- it's correct for now.
|
|
if type == "txp" then
|
|
if basefolder and basefolder.type ~= "invalid" and basefolder.type ~= "txp" then
|
|
return nil, fgettext("Unable to install a $1 as a texture pack", basefolder.type)
|
|
end
|
|
|
|
local from = basefolder and basefolder.path or path
|
|
if targetpath then
|
|
core.delete_dir(targetpath)
|
|
else
|
|
targetpath = core.get_texturepath() .. DIR_DELIM .. basename
|
|
end
|
|
if not core.copy_dir(from, targetpath, false) then
|
|
return nil,
|
|
fgettext("Failed to install $1 to $2", basename, targetpath)
|
|
end
|
|
return targetpath, nil
|
|
|
|
elseif not basefolder then
|
|
return nil, fgettext("Unable to find a valid mod or modpack")
|
|
end
|
|
|
|
--
|
|
-- Get destination
|
|
--
|
|
if basefolder.type == "modpack" then
|
|
if type ~= "mod" then
|
|
return nil, fgettext("Unable to install a modpack as a $1", type)
|
|
end
|
|
|
|
-- Get destination name for modpack
|
|
if targetpath then
|
|
core.delete_dir(targetpath)
|
|
else
|
|
local clean_path = nil
|
|
if basename ~= nil then
|
|
clean_path = basename
|
|
end
|
|
if not clean_path then
|
|
clean_path = get_last_folder(cleanup_path(basefolder.path))
|
|
end
|
|
if clean_path then
|
|
targetpath = core.get_modpath() .. DIR_DELIM .. clean_path
|
|
else
|
|
return nil,
|
|
fgettext("Install Mod: Unable to find suitable folder name for modpack $1",
|
|
path)
|
|
end
|
|
end
|
|
elseif basefolder.type == "mod" then
|
|
if type ~= "mod" then
|
|
return nil, fgettext("Unable to install a mod as a $1", type)
|
|
end
|
|
|
|
if targetpath then
|
|
core.delete_dir(targetpath)
|
|
else
|
|
local targetfolder = basename
|
|
if targetfolder == nil then
|
|
targetfolder = pkgmgr.identify_modname(basefolder.path, "init.lua")
|
|
end
|
|
|
|
-- If heuristic failed try to use current foldername
|
|
if targetfolder == nil then
|
|
targetfolder = get_last_folder(basefolder.path)
|
|
end
|
|
|
|
if targetfolder ~= nil and pkgmgr.isValidModname(targetfolder) then
|
|
targetpath = core.get_modpath() .. DIR_DELIM .. targetfolder
|
|
else
|
|
return nil, fgettext("Install Mod: Unable to find real mod name for: $1", path)
|
|
end
|
|
end
|
|
|
|
elseif basefolder.type == "game" then
|
|
if type ~= "game" then
|
|
return nil, fgettext("Unable to install a game as a $1", type)
|
|
end
|
|
|
|
if targetpath then
|
|
core.delete_dir(targetpath)
|
|
else
|
|
targetpath = core.get_gamepath() .. DIR_DELIM .. basename
|
|
end
|
|
end
|
|
|
|
-- Copy it
|
|
if not core.copy_dir(basefolder.path, targetpath, false) then
|
|
return nil,
|
|
fgettext("Failed to install $1 to $2", basename, targetpath)
|
|
end
|
|
|
|
if basefolder.type == "game" then
|
|
pkgmgr.update_gamelist()
|
|
else
|
|
pkgmgr.refresh_globals()
|
|
end
|
|
|
|
return targetpath, nil
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function pkgmgr.preparemodlist(data)
|
|
local retval = {}
|
|
|
|
local global_mods = {}
|
|
local game_mods = {}
|
|
|
|
--read global mods
|
|
local modpaths = core.get_modpaths()
|
|
for key, modpath in pairs(modpaths) do
|
|
get_mods(modpath, key, global_mods)
|
|
end
|
|
|
|
for i=1,#global_mods,1 do
|
|
global_mods[i].type = "mod"
|
|
global_mods[i].loc = "global"
|
|
global_mods[i].enabled = false
|
|
retval[#retval + 1] = global_mods[i]
|
|
end
|
|
|
|
--read game mods
|
|
local gamespec = pkgmgr.find_by_gameid(data.gameid)
|
|
pkgmgr.get_game_mods(gamespec, game_mods)
|
|
|
|
if #game_mods > 0 then
|
|
-- Add title
|
|
retval[#retval + 1] = {
|
|
type = "game",
|
|
is_game_content = true,
|
|
name = fgettext("$1 mods", gamespec.name),
|
|
path = gamespec.path
|
|
}
|
|
end
|
|
|
|
for i=1,#game_mods,1 do
|
|
game_mods[i].type = "mod"
|
|
game_mods[i].loc = "game"
|
|
game_mods[i].is_game_content = true
|
|
retval[#retval + 1] = game_mods[i]
|
|
end
|
|
|
|
if data.worldpath == nil then
|
|
return retval
|
|
end
|
|
|
|
--read world mod configuration
|
|
local filename = data.worldpath ..
|
|
DIR_DELIM .. "world.mt"
|
|
|
|
local worldfile = Settings(filename)
|
|
for key, value in pairs(worldfile:to_table()) do
|
|
if key:sub(1, 9) == "load_mod_" then
|
|
key = key:sub(10)
|
|
local mod_found = false
|
|
|
|
local fallback_found = false
|
|
local fallback_mod = nil
|
|
|
|
for i=1, #retval do
|
|
if retval[i].name == key and
|
|
not retval[i].is_modpack then
|
|
if core.is_yes(value) or retval[i].virtual_path == value then
|
|
retval[i].enabled = true
|
|
mod_found = true
|
|
break
|
|
elseif fallback_found then
|
|
-- Only allow fallback if only one mod matches
|
|
fallback_mod = nil
|
|
else
|
|
fallback_found = true
|
|
fallback_mod = retval[i]
|
|
end
|
|
end
|
|
end
|
|
|
|
if not mod_found then
|
|
if fallback_mod and value:find("/") then
|
|
fallback_mod.enabled = true
|
|
else
|
|
core.log("info", "Mod: " .. key .. " " .. dump(value) .. " but not found")
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
return retval
|
|
end
|
|
|
|
function pkgmgr.compare_package(a, b)
|
|
return a and b and a.name == b.name and a.path == b.path
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function pkgmgr.comparemod(elem1,elem2)
|
|
if elem1 == nil or elem2 == nil then
|
|
return false
|
|
end
|
|
if elem1.name ~= elem2.name then
|
|
return false
|
|
end
|
|
if elem1.is_modpack ~= elem2.is_modpack then
|
|
return false
|
|
end
|
|
if elem1.type ~= elem2.type then
|
|
return false
|
|
end
|
|
if elem1.modpack ~= elem2.modpack then
|
|
return false
|
|
end
|
|
|
|
if elem1.path ~= elem2.path then
|
|
return false
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function pkgmgr.mod_exists(basename)
|
|
|
|
if pkgmgr.global_mods == nil then
|
|
pkgmgr.refresh_globals()
|
|
end
|
|
|
|
if pkgmgr.global_mods:raw_index_by_uid(basename) > 0 then
|
|
return true
|
|
end
|
|
|
|
return false
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function pkgmgr.get_global_mod(idx)
|
|
|
|
if pkgmgr.global_mods == nil then
|
|
return nil
|
|
end
|
|
|
|
if idx == nil or idx < 1 or
|
|
idx > pkgmgr.global_mods:size() then
|
|
return nil
|
|
end
|
|
|
|
return pkgmgr.global_mods:get_list()[idx]
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function pkgmgr.refresh_globals()
|
|
local function is_equal(element,uid) --uid match
|
|
if element.name == uid then
|
|
return true
|
|
end
|
|
end
|
|
pkgmgr.global_mods = filterlist.create(pkgmgr.preparemodlist,
|
|
pkgmgr.comparemod, is_equal, nil, {})
|
|
pkgmgr.global_mods:add_sort_mechanism("alphabetic", sort_mod_list)
|
|
pkgmgr.global_mods:set_sortmode("alphabetic")
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function pkgmgr.find_by_gameid(gameid)
|
|
for i=1,#pkgmgr.games,1 do
|
|
if pkgmgr.games[i].id == gameid then
|
|
return pkgmgr.games[i], i
|
|
end
|
|
end
|
|
return nil, nil
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function pkgmgr.get_game_mods(gamespec, retval)
|
|
if gamespec ~= nil and
|
|
gamespec.gamemods_path ~= nil and
|
|
gamespec.gamemods_path ~= "" then
|
|
get_mods(gamespec.gamemods_path, ("games/%s/mods"):format(gamespec.id), retval)
|
|
end
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function pkgmgr.get_game_modlist(gamespec)
|
|
local retval = ""
|
|
local game_mods = {}
|
|
pkgmgr.get_game_mods(gamespec, game_mods)
|
|
for i=1,#game_mods,1 do
|
|
if retval ~= "" then
|
|
retval = retval..","
|
|
end
|
|
retval = retval .. game_mods[i].name
|
|
end
|
|
return retval
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function pkgmgr.get_game(index)
|
|
if index > 0 and index <= #pkgmgr.games then
|
|
return pkgmgr.games[index]
|
|
end
|
|
|
|
return nil
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function pkgmgr.update_gamelist()
|
|
pkgmgr.games = core.get_games()
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function pkgmgr.gamelist()
|
|
local retval = ""
|
|
if #pkgmgr.games > 0 then
|
|
retval = retval .. core.formspec_escape(pkgmgr.games[1].name)
|
|
|
|
for i=2,#pkgmgr.games,1 do
|
|
retval = retval .. "," .. core.formspec_escape(pkgmgr.games[i].name)
|
|
end
|
|
end
|
|
return retval
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- read initial data
|
|
--------------------------------------------------------------------------------
|
|
pkgmgr.update_gamelist()
|