// 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); } }