Translation to Portuguese of Brazil for Minetest
[oweals/minetest.git] / src / mods.h
1 /*
2 Minetest
3 Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU Lesser General Public License as published by
7 the Free Software Foundation; either version 2.1 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 GNU Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public License along
16 with this program; if not, write to the Free Software Foundation, Inc.,
17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19
20 #ifndef MODS_HEADER
21 #define MODS_HEADER
22
23 #include "irrlichttypes.h"
24 #include <irrList.h>
25 #include <list>
26 #include <set>
27 #include <vector>
28 #include <string>
29 #include <map>
30 #include <exception>
31 #include <list>
32
33 class ModError : public std::exception
34 {
35 public:
36         ModError(const std::string &s)
37         {
38                 m_s = "ModError: ";
39                 m_s += s;
40         }
41         virtual ~ModError() throw()
42         {}
43         virtual const char * what() const throw()
44         {
45                 return m_s.c_str();
46         }
47         std::string m_s;
48 };
49
50 struct ModSpec
51 {
52         std::string name;
53         std::string path;
54         //if normal mod:
55         std::set<std::string> depends;
56         std::set<std::string> unsatisfied_depends;
57
58         bool is_modpack;
59         // if modpack:
60         std::map<std::string,ModSpec> modpack_content;
61         ModSpec(const std::string name_="", const std::string path_="",
62                         const std::set<std::string> depends_=std::set<std::string>()):
63                 name(name_),
64                 path(path_),
65                 depends(depends_),
66                 unsatisfied_depends(depends_),
67                 is_modpack(false),      
68                 modpack_content()       
69         {}
70 };
71
72 std::map<std::string,ModSpec> getModsInPath(std::string path);
73
74 // expands modpack contents, but does not replace them.
75 std::map<std::string, ModSpec> flattenModTree(std::map<std::string, ModSpec> mods);
76
77 // replaces modpack Modspecs with their content
78 std::vector<ModSpec> flattenMods(std::map<std::string,ModSpec> mods);
79
80 // removes Mods mentioned in exclude_mod_names
81 std::vector<ModSpec> filterMods(std::vector<ModSpec> mods,
82                                                                 std::set<std::string> exclude_mod_names);
83
84 // a ModConfiguration is a subset of installed mods, expected to have
85 // all dependencies fullfilled, so it can be used as a list of mods to
86 // load when the game starts.
87 class ModConfiguration
88 {
89 public:
90         ModConfiguration():
91                 m_unsatisfied_mods(),
92                 m_sorted_mods()
93         {}
94
95                 
96         ModConfiguration(std::string worldpath);
97
98         // adds all mods in the given path. used for games, modpacks
99         // and world-specific mods (worldmods-folders)
100         void addModsInPath(std::string path)
101         {
102                 addMods(flattenMods(getModsInPath(path)));
103         }
104
105         // adds all mods in the given path whose name does not appear
106         // in the exclude_mods set. 
107         void addModsInPathFiltered(std::string path, std::set<std::string> exclude_mods);
108
109         // adds all mods in the set.
110         void addMods(std::vector<ModSpec> mods);
111
112         // checks if all dependencies are fullfilled.
113         bool isConsistent()
114         {
115                 return m_unsatisfied_mods.empty();
116         }
117
118         std::vector<ModSpec> getMods()
119         {
120                 return m_sorted_mods;
121         }
122
123         std::list<ModSpec> getUnsatisfiedMods()
124         {
125                 return m_unsatisfied_mods;
126         }
127
128 private:
129
130         // mods with unmet dependencies. This is a list and not a
131         // vector because we want easy removal of elements at every
132         // position.
133         std::list<ModSpec> m_unsatisfied_mods;
134
135         // list of mods sorted such that they can be loaded in the
136         // given order with all dependencies being fullfilled. I.e.,
137         // every mod in this list has only dependencies on mods which
138         // appear earlier in the vector.
139         std::vector<ModSpec> m_sorted_mods;
140
141 };
142
143 #endif