// load a material object from incoming JSON
void material_type::load_material( JsonObject &jsobj )
{
material_type mat;
mat._ident = jsobj.get_string( "ident" );
mat._name = _( jsobj.get_string( "name" ).c_str() );
mat._salvage_id = jsobj.get_string( "salvage_id", "null" );
mat._salvage_multiplier = jsobj.get_float( "salvage_multiplier", 1.0 );
mat._bash_resist = jsobj.get_int( "bash_resist" );
mat._cut_resist = jsobj.get_int( "cut_resist" );
mat._bash_dmg_verb = _( jsobj.get_string( "bash_dmg_verb" ).c_str() );
mat._cut_dmg_verb = _( jsobj.get_string( "cut_dmg_verb" ).c_str() );
mat._acid_resist = jsobj.get_int( "acid_resist" );
mat._elec_resist = jsobj.get_int( "elec_resist" );
mat._fire_resist = jsobj.get_int( "fire_resist" );
mat._chip_resist = jsobj.get_int( "chip_resist" );
mat._density = jsobj.get_int( "density" );
JsonArray jsarr = jsobj.get_array( "dmg_adj" );
mat._dmg_adj[0] = _( jsarr.next_string().c_str() );
mat._dmg_adj[1] = _( jsarr.next_string().c_str() );
mat._dmg_adj[2] = _( jsarr.next_string().c_str() );
mat._dmg_adj[3] = _( jsarr.next_string().c_str() );
_all_materials[mat._ident] = mat;
DebugLog( D_INFO, DC_ALL ) << "Loaded material: " << mat._name;
}
void profession::load_profession(JsonObject &jsobj)
{
profession prof;
JsonArray jsarr;
prof._ident = jsobj.get_string("ident");
prof._name = _(jsobj.get_string("name").c_str());
prof._description = _(jsobj.get_string("description").c_str());
prof._point_cost = jsobj.get_int("points");
jsarr = jsobj.get_array("items");
while (jsarr.has_more()) {
prof.add_item(jsarr.next_string());
}
jsarr = jsobj.get_array("skills");
while (jsarr.has_more()) {
JsonObject jo = jsarr.next_object();
prof.add_skill(jo.get_string("name"),
jo.get_int("level"));
}
jsarr = jsobj.get_array("addictions");
while (jsarr.has_more()) {
JsonObject jo = jsarr.next_object();
prof.add_addiction(addiction_type(jo.get_string("type")),
jo.get_int("intensity"));
}
jsarr = jsobj.get_array("flags");
while (jsarr.has_more()) {
prof.flags.insert(jsarr.next_string());
}
_all_profs[prof._ident] = prof;
//dout(D_INFO) << "Loaded profession: " << prof._name;
}
void mutation_branch::load_trait_group( JsonObject &jsobj, const trait_group::Trait_group_tag &gid,
const std::string &subtype )
{
if( subtype != "distribution" && subtype != "collection" && subtype != "old" ) {
jsobj.throw_error( "unknown trait group type", "subtype" );
}
Trait_group &tg = make_group_or_throw( gid, ( subtype == "collection" || subtype == "old" ) );
// TODO: (sm) Looks like this makes the new code backwards-compatible with the old format. Great if so!
if( subtype == "old" ) {
JsonArray traits = jsobj.get_array( "traits" );
while( traits.has_more() ) {
JsonArray pair = traits.next_array();
tg.add_trait_entry( trait_id( pair.get_string( 0 ) ), pair.get_int( 1 ) );
}
return;
}
// TODO: (sm) Taken from item_factory.cpp almost verbatim. Ensure that these work!
if( jsobj.has_member( "entries" ) ) {
JsonArray traits = jsobj.get_array( "entries" );
while( traits.has_more() ) {
JsonObject subobj = traits.next_object();
add_entry( tg, subobj );
}
}
if( jsobj.has_member( "traits" ) ) {
JsonArray traits = jsobj.get_array( "traits" );
while( traits.has_more() ) {
if( traits.test_string() ) {
tg.add_trait_entry( trait_id( traits.next_string() ), 100 );
} else if( traits.test_array() ) {
JsonArray subtrait = traits.next_array();
tg.add_trait_entry( trait_id( subtrait.get_string( 0 ) ), subtrait.get_int( 1 ) );
} else {
JsonObject subobj = traits.next_object();
add_entry( tg, subobj );
}
}
}
if( jsobj.has_member( "groups" ) ) {
JsonArray traits = jsobj.get_array( "groups" );
while( traits.has_more() ) {
if( traits.test_string() ) {
tg.add_group_entry( trait_group::Trait_group_tag( traits.next_string() ), 100 );
} else if( traits.test_array() ) {
JsonArray subtrait = traits.next_array();
tg.add_group_entry( trait_group::Trait_group_tag( traits.get_string( 0 ) ), subtrait.get_int( 1 ) );
} else {
JsonObject subobj = traits.next_object();
add_entry( tg, subobj );
}
}
}
}
void profession::load_profession(JsonObject &jsobj)
{
profession prof;
JsonArray jsarr;
prof._ident = jsobj.get_string("ident");
//If the "name" is an object then we have to deal with gender-specific titles,
if(jsobj.has_object("name")) {
JsonObject name_obj = jsobj.get_object("name");
prof._name_male = pgettext("profession_male", name_obj.get_string("male").c_str());
prof._name_female = pgettext("profession_female", name_obj.get_string("female").c_str());
} else {
// Same profession names for male and female in English.
// Still need to different names in other languages.
const std::string name = jsobj.get_string("name");
prof._name_female = pgettext("profession_female", name.c_str());
prof._name_male = pgettext("profession_male", name.c_str());
}
const std::string desc = jsobj.get_string("description").c_str();
prof._description_male = pgettext("prof_desc_male", desc.c_str());
prof._description_female = pgettext("prof_desc_female", desc.c_str());
prof._point_cost = jsobj.get_int("points");
JsonObject items_obj = jsobj.get_object("items");
prof.add_items_from_jsonarray(items_obj.get_array("both"), "both");
prof.add_items_from_jsonarray(items_obj.get_array("male"), "male");
prof.add_items_from_jsonarray(items_obj.get_array("female"), "female");
jsarr = jsobj.get_array("skills");
while (jsarr.has_more()) {
JsonObject jo = jsarr.next_object();
prof.add_skill(jo.get_string("name"),
jo.get_int("level"));
}
jsarr = jsobj.get_array("addictions");
while (jsarr.has_more()) {
JsonObject jo = jsarr.next_object();
prof.add_addiction(addiction_type(jo.get_string("type")),
jo.get_int("intensity"));
}
jsarr = jsobj.get_array("CBMs");
while (jsarr.has_more()) {
prof.add_CBM(jsarr.next_string());
}
jsarr = jsobj.get_array("flags");
while (jsarr.has_more()) {
prof.flags.insert(jsarr.next_string());
}
_all_profs[prof._ident] = prof;
DebugLog( D_INFO, DC_ALL ) << "Loaded profession: " << prof._ident;
}
void load_technique(JsonObject &jo)
{
ma_technique tec;
tec.id = jo.get_string("id");
tec.name = jo.get_string("name", "");
if (!tec.name.empty()) {
tec.name = _(tec.name.c_str());
}
JsonArray jsarr = jo.get_array("messages");
while (jsarr.has_more()) {
tec.messages.push_back(_(jsarr.next_string().c_str()));
}
tec.reqs.unarmed_allowed = jo.get_bool("unarmed_allowed", false);
tec.reqs.melee_allowed = jo.get_bool("melee_allowed", false);
tec.reqs.min_melee = jo.get_int("min_melee", 0);
tec.reqs.min_unarmed = jo.get_int("min_unarmed", 0);
tec.reqs.min_bashing = jo.get_int("min_bashing", 0);
tec.reqs.min_cutting = jo.get_int("min_cutting", 0);
tec.reqs.min_stabbing = jo.get_int("min_stabbing", 0);
tec.reqs.min_bashing_damage = jo.get_int("min_bashing_damage", 0);
tec.reqs.min_cutting_damage = jo.get_int("min_cutting_damage", 0);
tec.reqs.req_buffs = jo.get_tags("req_buffs");
tec.reqs.req_flags = jo.get_tags("req_flags");
tec.crit_tec = jo.get_bool("crit_tec", false);
tec.defensive = jo.get_bool("defensive", false);
tec.disarms = jo.get_bool("disarms", false);
tec.dodge_counter = jo.get_bool("dodge_counter", false);
tec.block_counter = jo.get_bool("block_counter", false);
tec.miss_recovery = jo.get_bool("miss_recovery", false);
tec.grab_break = jo.get_bool("grab_break", false);
tec.flaming = jo.get_bool("flaming", false);
tec.hit = jo.get_int("pain", 0);
tec.bash = jo.get_int("bash", 0);
tec.cut = jo.get_int("cut", 0);
tec.pain = jo.get_int("pain", 0);
tec.weighting = jo.get_int("weighting", 1);
tec.bash_mult = jo.get_float("bash_mult", 1.0);
tec.cut_mult = jo.get_float("cut_mult", 1.0);
tec.speed_mult = jo.get_float("speed_mult", 1.0);
tec.down_dur = jo.get_int("down_dur", 0);
tec.stun_dur = jo.get_int("stun_dur", 0);
tec.knockback_dist = jo.get_int("knockback_dist", 0);
tec.knockback_spread = jo.get_int("knockback_spread", 0);
tec.aoe = jo.get_string("aoe", "");
tec.flags = jo.get_tags("flags");
ma_techniques[tec.id] = tec;
}
void load_recipe_category( JsonObject &jsobj )
{
JsonArray subcats;
std::string category = jsobj.get_string( "id" );
if( category.find( "CC_" ) != 0 ) {
jsobj.throw_error( "Crafting category id has to be prefixed with 'CC_'" );
}
// Don't store noncraft as a category.
// We're storing the subcategory so we can look it up in load_recipes
// for the fallback subcategory.
if( category != "CC_NONCRAFT" ) {
craft_cat_list.push_back( category );
}
std::string cat_name = get_cat_name( category );
craft_subcat_list[category] = std::vector<std::string>();
subcats = jsobj.get_array( "recipe_subcategories" );
while( subcats.has_more() ) {
std::string subcat_id = subcats.next_string();
if( subcat_id.find( "CSC_" + cat_name + "_" ) != 0 && subcat_id != "CSC_ALL" &&
subcat_id != "CSC_NONCRAFT" ) {
jsobj.throw_error( "Crafting sub-category id has to be prefixed with CSC_<category_name>_" );
}
craft_subcat_list[category].push_back( subcat_id );
}
}
void load_furniture(JsonObject &jsobj)
{
if ( furnlist.empty() ) {
furn_t new_null = null_furniture_t();
furnmap[new_null.id] = new_null;
furnlist.push_back(new_null);
}
furn_t new_furniture;
new_furniture.id = jsobj.get_string("id");
if ( new_furniture.id == "f_null" ) {
return;
}
new_furniture.name = _(jsobj.get_string("name").c_str());
new_furniture.sym = jsobj.get_string("symbol").c_str()[0];
bool has_color = jsobj.has_member("color");
bool has_bgcolor = jsobj.has_member("bgcolor");
if(has_color && has_bgcolor) {
debugmsg("Found both color and bgcolor for %s, use only one of these.", new_furniture.name.c_str());
new_furniture.color = c_white;
} else if(has_color) {
new_furniture.color = color_from_string(jsobj.get_string("color"));
} else if(has_bgcolor) {
new_furniture.color = bgcolor_from_string(jsobj.get_string("bgcolor"));
} else {
debugmsg("Furniture %s needs at least one of: color, bgcolor.", new_furniture.name.c_str());
}
new_furniture.movecost = jsobj.get_int("move_cost_mod");
new_furniture.move_str_req = jsobj.get_int("required_str");
new_furniture.transparent = false;
new_furniture.bitflags = 0;
JsonArray flags = jsobj.get_array("flags");
while(flags.has_more()) {
new_furniture.set_flag(flags.next_string());
}
if(jsobj.has_member("examine_action")) {
std::string function_name = jsobj.get_string("examine_action");
new_furniture.examine = iexamine_function_from_string(function_name);
} else {
//If not specified, default to no action
new_furniture.examine = iexamine_function_from_string("none");
}
new_furniture.open = "";
if ( jsobj.has_member("open") ) {
new_furniture.open = jsobj.get_string("open");
}
new_furniture.close = "";
if ( jsobj.has_member("close") ) {
new_furniture.close = jsobj.get_string("close");
}
new_furniture.bash.load(jsobj, "bash", true);
new_furniture.loadid = furnlist.size();
furnmap[new_furniture.id] = new_furniture;
furnlist.push_back(new_furniture);
}
void mod_manager::load_mods_list(WORLDPTR world) const
{
if (world == NULL) {
return;
}
std::vector<std::string> &amo = world->active_mod_order;
amo.clear();
bool obsolete_mod_found = false;
read_from_file_optional_json( get_mods_list_file( world ), [&]( JsonIn &jsin ) {
JsonArray ja = jsin.get_array();
while (ja.has_more()) {
const std::string mod = ja.next_string();
if( mod.empty() || std::find(amo.begin(), amo.end(), mod) != amo.end() ) {
continue;
}
if( mod_replacements.count( mod ) ) {
amo.push_back( mod_replacements[ mod ] );
obsolete_mod_found = true;
} else {
amo.push_back(mod);
}
}
} );
if( obsolete_mod_found ) {
// If we found an obsolete mod, overwrite the mod list without the obsolete one.
save_mods_list(world);
}
}
void mod_manager::load_mods_list(WORLDPTR world) const
{
if (world == NULL) {
return;
}
std::vector<std::string> &amo = world->active_mod_order;
amo.clear();
std::ifstream mods_list_file(get_mods_list_file(world).c_str(), std::ios::in | std::ios::binary);
if (!mods_list_file) {
return;
}
try {
JsonIn jsin(mods_list_file);
JsonArray ja = jsin.get_array();
while (ja.has_more()) {
const std::string mod = ja.next_string();
if (mod.empty() || std::find(amo.begin(), amo.end(), mod) != amo.end()) {
continue;
}
amo.push_back(mod);
}
} catch (std::string e) {
DebugLog( D_ERROR, DC_ALL ) << "worldfactory: loading mods list failed: " << e;
}
}
void mutation_branch::load_trait_blacklist( JsonObject &jsobj )
{
JsonArray jarr = jsobj.get_array( "traits" );
while( jarr.has_more() ) {
trait_blacklist.insert( trait_id( jarr.next_string() ) );
}
}
void mutation_branch::load( JsonObject &jsobj )
{
const std::string id = jsobj.get_string( "id" );
mutation_branch &new_mut = mutation_data[id];
JsonArray jsarr;
new_mut.name = _(jsobj.get_string("name").c_str());
new_mut.description = _(jsobj.get_string("description").c_str());
new_mut.points = jsobj.get_int("points");
new_mut.visibility = jsobj.get_int("visibility", 0);
new_mut.ugliness = jsobj.get_int("ugliness", 0);
new_mut.startingtrait = jsobj.get_bool("starting_trait", false);
new_mut.mixed_effect = jsobj.get_bool("mixed_effect", false);
new_mut.activated = jsobj.get_bool("active", false);
new_mut.cost = jsobj.get_int("cost", 0);
new_mut.cooldown = jsobj.get_int("time",0);
new_mut.hunger = jsobj.get_bool("hunger",false);
new_mut.thirst = jsobj.get_bool("thirst",false);
new_mut.fatigue = jsobj.get_bool("fatigue",false);
new_mut.valid = jsobj.get_bool("valid", true);
new_mut.purifiable = jsobj.get_bool("purifiable", true);
new_mut.initial_ma_styles = jsobj.get_string_array( "initial_ma_styles" );
new_mut.threshold = jsobj.get_bool("threshold", false);
new_mut.profession = jsobj.get_bool("profession", false);
load_mutation_mods(jsobj, "passive_mods", new_mut.mods);
/* Not currently supported due to inability to save active mutation state
load_mutation_mods(jsobj, "active_mods", new_mut.mods); */
new_mut.prereqs = jsobj.get_string_array( "prereqs" );
// Helps to be able to have a trait require more than one other trait
// (Individual prereq-lists are "OR", not "AND".)
// Traits shoud NOT appear in both lists for a given mutation, unless
// you want that trait to satisfy both requirements.
// These are additional to the first list.
new_mut.prereqs2 = jsobj.get_string_array( "prereqs2" );
// Dedicated-purpose prereq slot for Threshold mutations
// Stuff like Huge might fit in more than one mutcat post-threshold, so yeah
new_mut.threshreq = jsobj.get_string_array( "threshreq" );
new_mut.cancels = jsobj.get_string_array( "cancels" );
new_mut.replacements = jsobj.get_string_array( "changes_to" );
new_mut.additions = jsobj.get_string_array( "leads_to" );
jsarr = jsobj.get_array("category");
while (jsarr.has_more()) {
std::string s = jsarr.next_string();
new_mut.category.push_back(s);
mutations_category[s].push_back(id);
}
jsarr = jsobj.get_array("wet_protection");
while (jsarr.has_more()) {
JsonObject jo = jsarr.next_object();
std::string part_id = jo.get_string("part");
int ignored = jo.get_int("ignored", 0);
int neutral = jo.get_int("neutral", 0);
int good = jo.get_int("good", 0);
tripoint protect = tripoint(ignored, neutral, good);
new_mut.protection[part_id] = mutation_wet(body_parts[part_id], protect);
}
}
std::vector<std::string> JsonObject::get_string_array(const std::string &name)
{
JsonArray ja = get_array(name);
std::vector<std::string> ret;
while (ja.has_more()) {
ret.push_back(ja.next_string());
}
return ret;
}
void load_tutorial_messages( JsonObject &jo )
{
// loading them all at once, as they have to be in exact order
tut_text.clear();
JsonArray messages = jo.get_array( "messages" );
while( messages.has_more() ) {
tut_text.push_back( _( messages.next_string().c_str() ) );
}
}
json_item_substitution::substitution::info json_item_substitution::substitution::info::load(
JsonArray &arr )
{
json_item_substitution::substitution::info ret;
ret.new_item = arr.next_string();
if( arr.test_float() && ( ret.ratio = arr.next_float() ) <= 0.0 ) {
arr.throw_error( "Ratio must be positive" );
}
return ret;
}
void tool_comp::load( JsonArray &ja )
{
if( ja.test_string() ) {
// constructions uses this format: [ "tool", ... ]
type = ja.next_string();
count = -1;
} else {
JsonArray comp = ja.next_array();
type = comp.get_string( 0 );
count = comp.get_int( 1 );
}
}
void snippet_library::add_snippets_from_json( const std::string &category, JsonArray &jarr )
{
while( jarr.has_more() ) {
if( jarr.test_string() ) {
const std::string text = _( jarr.next_string().c_str() );
add_snippet( category, text );
} else {
JsonObject jo = jarr.next_object();
add_snippet_from_json( category, jo );
}
}
}
std::set<std::string> JsonObject::get_tags(std::string name)
{
std::set<std::string> ret;
int pos = positions[name];
if (pos <= start) {
return ret; // empty set
}
jsin->seek(pos);
JsonArray jsarr = jsin->get_array();
while (jsarr.has_more()) {
ret.insert(jsarr.next_string());
}
return ret;
}
void load_dream(JsonObject &jsobj)
{
dream newdream;
newdream.strength = jsobj.get_int("strength");
newdream.category = jsobj.get_string("category");
JsonArray jsarr = jsobj.get_array("messages");
while (jsarr.has_more()) {
newdream.messages.push_back(_(jsarr.next_string().c_str()));
}
dreams.push_back(newdream);
}
// load a material object from incoming JSON
void material_type::load_material(JsonObject &jsobj)
{
material_type mat;
mat._ident = jsobj.get_string("ident");
mat._name = _(jsobj.get_string("name").c_str());
mat._bash_resist = jsobj.get_int("bash_resist");
mat._cut_resist = jsobj.get_int("cut_resist");
mat._bash_dmg_verb = _(jsobj.get_string("bash_dmg_verb").c_str());
mat._cut_dmg_verb = _(jsobj.get_string("cut_dmg_verb").c_str());
mat._acid_resist = jsobj.get_int("acid_resist");
mat._elec_resist = jsobj.get_int("elec_resist");
mat._fire_resist = jsobj.get_int("fire_resist");
mat._density = jsobj.get_int("density");
JsonArray jsarr = jsobj.get_array("dmg_adj");
mat._dmg_adj[0] = _(jsarr.next_string().c_str());
mat._dmg_adj[1] = _(jsarr.next_string().c_str());
mat._dmg_adj[2] = _(jsarr.next_string().c_str());
mat._dmg_adj[3] = _(jsarr.next_string().c_str());
_all_materials[mat._ident] = mat;
//dout(D_INFO) << "Loaded material: " << mat._name;
}
void material_type::load( JsonObject &jsobj )
{
mandatory( jsobj, was_loaded, "name", _name, translated_string_reader );
mandatory( jsobj, was_loaded, "bash_resist", _bash_resist );
mandatory( jsobj, was_loaded, "cut_resist", _cut_resist );
mandatory( jsobj, was_loaded, "acid_resist", _acid_resist );
mandatory( jsobj, was_loaded, "elec_resist", _elec_resist );
mandatory( jsobj, was_loaded, "fire_resist", _fire_resist );
mandatory( jsobj, was_loaded, "chip_resist", _chip_resist );
mandatory( jsobj, was_loaded, "density", _density );
optional( jsobj, was_loaded, "salvaged_into", _salvaged_into, "null" );
optional( jsobj, was_loaded, "repaired_with", _repaired_with, "null" );
optional( jsobj, was_loaded, "edible", _edible, false );
optional( jsobj, was_loaded, "soft", _soft, false );
auto arr = jsobj.get_array( "vitamins" );
while( arr.has_more() ) {
auto pair = arr.next_array();
_vitamins.emplace( vitamin_id( pair.get_string( 0 ) ), pair.get_float( 1 ) );
}
mandatory( jsobj, was_loaded, "bash_dmg_verb", _bash_dmg_verb, translated_string_reader );
mandatory( jsobj, was_loaded, "cut_dmg_verb", _cut_dmg_verb, translated_string_reader );
JsonArray jsarr = jsobj.get_array( "dmg_adj" );
while( jsarr.has_more() ) {
_dmg_adj.push_back( _( jsarr.next_string().c_str() ) );
}
JsonArray burn_data_array = jsobj.get_array( "burn_data" );
for( size_t intensity = 0; intensity < MAX_FIELD_DENSITY; intensity++ ) {
if( burn_data_array.has_more() ) {
JsonObject brn = burn_data_array.next_object();
_burn_data[ intensity ] = load_mat_burn_data( brn );
} else {
// If not specified, supply default
bool flammable = _fire_resist <= ( int )intensity;
mat_burn_data mbd;
if( flammable ) {
mbd.burn = 1;
}
_burn_data[ intensity ] = mbd;
}
}
}
void Skill::load_skill(JsonObject &jsobj)
{
std::string ident = jsobj.get_string("ident");
std::string name = _(jsobj.get_string("name").c_str());
std::string description = _(jsobj.get_string("description").c_str());
std::set<std::string> tags;
JsonArray jsarr = jsobj.get_array("tags");
while (jsarr.has_more()) {
tags.insert(jsarr.next_string());
}
Skill *sk = new Skill(skills.size(), ident, name, description, tags);
skills.push_back(sk);
//dout(D_INFO) << "Loaded skill: " << name << "\n";
}
void tool_comp::load( JsonArray &ja )
{
if( ja.test_string() ) {
// constructions uses this format: [ "tool", ... ]
type = ja.next_string();
count = -1;
} else {
JsonArray comp = ja.next_array();
type = comp.get_string( 0 );
count = comp.get_int( 1 );
}
if( count == 0 ) {
ja.throw_error( "tool count must not be 0" );
}
// Note: negative count means charges (of the tool) should be consumed
}
unsigned Item_factory::flags_from_json(JsonObject& jo, std::string member, std::string flag_type)
{
//If none is found, just use the standard none action
unsigned flag = 0;
//Otherwise, grab the right label to look for
if ( jo.has_array(member) ) {
JsonArray jarr = jo.get_array(member);
while (jarr.has_more()){
set_flag_by_string(flag, jarr.next_string(), flag_type);
}
} else if ( jo.has_string(member) ) {
//we should have gotten a string, if not an array
set_flag_by_string(flag, jo.get_string(member), flag_type);
}
return flag;
}
void json_item_substitution::do_load( JsonObject &jo )
{
const bool item_mode = jo.has_string( "item" );
const std::string title = jo.get_string( item_mode ? "item" : "trait" );
auto check_duplicate_item = [&]( const itype_id & it ) {
return substitutions.find( it ) != substitutions.end() ||
std::find_if( bonuses.begin(), bonuses.end(),
[&it]( const std::pair<itype_id, trait_requirements> &p ) {
return p.first == it;
} ) != bonuses.end();
};
if( item_mode && check_duplicate_item( title ) ) {
jo.throw_error( "Duplicate definition of item" );
}
if( jo.has_array( "bonus" ) ) {
if( !item_mode ) {
jo.throw_error( "Bonuses can only be used in item mode" );
}
JsonArray arr = jo.get_array( "bonus" );
bonuses.emplace_back( title, trait_requirements::load( arr ) );
} else if( !jo.has_array( "sub" ) ) {
jo.throw_error( "Missing sub array" );
}
JsonArray sub = jo.get_array( "sub" );
while( sub.has_more() ) {
JsonArray line = sub.next_array();
substitution s;
const itype_id old_it = item_mode ? title : line.next_string();
if( item_mode ) {
s.trait_reqs = trait_requirements::load( line );
} else {
if( check_duplicate_item( old_it ) ) {
line.throw_error( "Duplicate definition of item" );
}
s.trait_reqs.present.push_back( trait_id( title ) );
}
// Error if the array doesn't have at least one new_item
do {
s.infos.push_back( substitution::info::load( line ) );
} while( line.has_more() );
substitutions[old_it].push_back( s );
}
}
bool Item_factory::is_mod_target(JsonObject& jo, std::string member, std::string weapon)
{
//If none is found, just use the standard none action
unsigned is_included = false;
//Otherwise, grab the right label to look for
if ( jo.has_array(member) ) {
JsonArray jarr = jo.get_array(member);
while (jarr.has_more() && is_included == false){
if (jarr.next_string() == weapon){
is_included = true;
}
}
} else {
if (jo.get_string(member) == weapon){
is_included = true;
}
}
return is_included;
}
void sfx::load_sound_effects( JsonObject &jsobj )
{
if( !sound_init_success ) {
return;
}
const id_and_variant key( jsobj.get_string( "id" ), jsobj.get_string( "variant", "default" ) );
const int volume = jsobj.get_int( "volume", 100 );
auto &effects = sfx_resources.sound_effects[ key ];
JsonArray jsarr = jsobj.get_array( "files" );
while( jsarr.has_more() ) {
sound_effect new_sound_effect;
const std::string file = jsarr.next_string();
new_sound_effect.volume = volume;
new_sound_effect.resource_id = add_sfx_path( file );
effects.push_back( new_sound_effect );
}
}
std::set<std::string> JsonObject::get_tags(const std::string &name)
{
std::set<std::string> ret;
int pos = positions[name];
if (pos <= start) {
return ret; // empty set
}
jsin->seek(pos);
// allow single string as tag
if (jsin->test_string()) {
ret.insert(jsin->get_string());
return ret;
}
// otherwise assume it's an array and error if it isn't.
JsonArray jsarr = jsin->get_array();
while (jsarr.has_more()) {
ret.insert(jsarr.next_string());
}
return ret;
}
void load_recipe_category( JsonObject &jsobj )
{
std::string category = jsobj.get_string( "id" );
if( category.find( "CC_" ) != 0 ) {
jsobj.throw_error( "Crafting category id has to be prefixed with 'CC_'" );
}
craft_cat_list.push_back( category );
std::string cat_name = get_cat_name( category );
craft_subcat_list[category] = std::vector<std::string>();
JsonArray subcats = jsobj.get_array( "recipe_subcategories" );
while( subcats.has_more() ) {
std::string subcat_id = subcats.next_string();
if( subcat_id.find( "CSC_" + cat_name + "_" ) != 0 && subcat_id != "CSC_ALL" ) {
jsobj.throw_error( "Crafting sub-category id has to be prefixed with CSC_<category_name>_" );
}
craft_subcat_list[category].push_back( subcat_id );
}
}
void Skill::load_skill(JsonObject &jsobj)
{
std::string ident = jsobj.get_string("ident");
for(std::vector<const Skill*>::iterator a = skills.begin(); a != skills.end(); ++a) {
if ((*a)->_ident == ident) {
delete *a;
skills.erase(a);
break;
}
}
std::string name = _(jsobj.get_string("name").c_str());
std::string description = _(jsobj.get_string("description").c_str());
std::set<std::string> tags;
JsonArray jsarr = jsobj.get_array("tags");
while (jsarr.has_more()) {
tags.insert(jsarr.next_string());
}
const Skill* sk = new Skill(skills.size(), ident, name, description, tags);
skills.push_back(sk);
DebugLog( D_INFO, DC_ALL ) << "Loaded skill: " << name;
}
void mod_manager::load_mods_list(WORLDPTR world) const
{
if (world == NULL) {
return;
}
std::vector<std::string> &amo = world->active_mod_order;
amo.clear();
std::ifstream mods_list_file( get_mods_list_file(world).c_str(),
std::ios::in | std::ios::binary );
if (!mods_list_file) {
return;
}
bool obsolete_mod_found = false;
try {
JsonIn jsin(mods_list_file);
JsonArray ja = jsin.get_array();
while (ja.has_more()) {
const std::string mod = ja.next_string();
if( mod.empty() || std::find(amo.begin(), amo.end(), mod) != amo.end() ) {
continue;
}
if( obsolete_mod_list.count( mod ) ) {
obsolete_mod_found = true;
continue;
}
amo.push_back(mod);
}
} catch (std::string e) {
DebugLog( D_ERROR, DC_ALL ) << "worldfactory: loading mods list failed: " << e;
}
if( obsolete_mod_found ) {
// If we found an obsolete mod, overwrite the mod list without the obsolete one.
save_mods_list(world);
}
}
