static void load_mutation_mods(JsonObject &jsobj, std::string member, std::unordered_map<std::pair<bool, std::string>, int> &mods) { if (jsobj.has_object(member)) { JsonObject j = jsobj.get_object(member); bool active = false; if (member == "active_mods") { active = true; } // json field type key extract_mod(j, mods, "str_mod", active, "STR"); extract_mod(j, mods, "dex_mod", active, "DEX"); extract_mod(j, mods, "per_mod", active, "PER"); extract_mod(j, mods, "int_mod", active, "INT"); } }
bool map_deconstruct_info::load(JsonObject &jsobj, std::string member, bool isfurniture) { if (!jsobj.has_object(member)) { return false; } JsonObject j = jsobj.get_object(member); jsonstring(j, "furn_set", furn_set ); if (!isfurniture) { ter_set = j.get_string("ter_set"); } can_do = true; load_map_bash_item_drop_list(j.get_array("items"), items); return true; }
bool map_bash_info::load(JsonObject &jsobj, const std::string &member, bool is_furniture) { if( !jsobj.has_object(member) ) { return false; } JsonObject j = jsobj.get_object(member); str_min = j.get_int("str_min", 0); str_max = j.get_int("str_max", 0); str_min_blocked = j.get_int("str_min_blocked", -1); str_max_blocked = j.get_int("str_max_blocked", -1); str_min_supported = j.get_int("str_min_supported", -1); str_max_supported = j.get_int("str_max_supported", -1); explosive = j.get_int("explosive", -1); sound_vol = j.get_int("sound_vol", -1); sound_fail_vol = j.get_int("sound_fail_vol", -1); collapse_radius = j.get_int( "collapse_radius", 1 ); destroy_only = j.get_bool("destroy_only", false); bash_below = j.get_bool("bash_below", false); sound = j.get_string("sound", _("smash!")); sound_fail = j.get_string("sound_fail", _("thump!")); if( is_furniture ) { furn_set = furn_str_id( j.get_string( "furn_set", "f_null" ) ); } else { ter_set = ter_str_id( j.get_string( "ter_set" ) ); } if( j.has_member( "items" ) ) { JsonIn& stream = *j.get_raw( "items" ); drop_group = item_group::load_item_group( stream, "collection" ); } else { drop_group = "EMPTY_GROUP"; } if( j.has_array("tent_centers") ) { load_map_bash_tent_centers( j.get_array("tent_centers"), tent_centers ); } return true; }
bool map_deconstruct_info::load(JsonObject &jsobj, std::string member, bool isfurniture) { if (!jsobj.has_object(member)) { return false; } JsonObject j = jsobj.get_object(member); furn_set = j.get_string("furn_set", ""); if (!isfurniture) { ter_set = j.get_string( "ter_set" ); } can_do = true; JsonIn& stream = *j.get_raw( "items" ); drop_group = item_group::load_item_group( stream, "collection" ); return true; }
void gate_data::load( JsonObject &jo ) { mandatory( jo, was_loaded, "door", door ); mandatory( jo, was_loaded, "floor", floor ); mandatory( jo, was_loaded, "walls", walls, string_id_reader<ter_t> {} ); if( !was_loaded || jo.has_member( "messages" ) ) { JsonObject messages_obj = jo.get_object( "messages" ); optional( messages_obj, was_loaded, "pull", pull_message, translated_string_reader ); optional( messages_obj, was_loaded, "open", open_message, translated_string_reader ); optional( messages_obj, was_loaded, "close", close_message, translated_string_reader ); optional( messages_obj, was_loaded, "fail", fail_message, translated_string_reader ); } optional( jo, was_loaded, "moves", moves, 0 ); optional( jo, was_loaded, "bashing_damage", bash_dmg, 0 ); }
distribution load_distribution( JsonObject &jo, const std::string &name ) { if( !jo.has_member( name ) ) { return distribution(); } if( jo.has_float( name ) ) { return distribution::constant( jo.get_float( name ) ); } if( jo.has_object( name ) ) { JsonObject obj = jo.get_object( name ); return load_distribution( obj ); } jo.throw_error( "Invalid distribution type", name ); return distribution(); }
bool map_bash_info::load(JsonObject &jsobj, std::string member, bool isfurniture) { if( jsobj.has_object(member) ) { JsonObject j = jsobj.get_object(member); str_min = j.get_int("str_min", 0); str_max = j.get_int("str_max", 0); str_min_blocked = j.get_int("str_min_blocked", -1); str_max_blocked = j.get_int("str_max_blocked", -1); str_min_supported = j.get_int("str_min_supported", -1); str_max_supported = j.get_int("str_max_supported", -1); str_min_roll = j.get_int("str_min_roll", str_min); str_max_roll = j.get_int("str_min_roll", str_max); explosive = j.get_int("explosive", -1); sound_vol = j.get_int("sound_vol", -1); sound_fail_vol = j.get_int("sound_fail_vol", -1); destroy_only = j.get_bool("destroy_only", false); bash_below = j.get_bool("bash_below", false); sound = j.get_string("sound", _("smash!")); sound_fail = j.get_string("sound_fail", _("thump!")); if (isfurniture) { furn_set = j.get_string("furn_set", "f_null"); } else { ter_set = j.get_string( "ter_set" ); } if ( j.has_array("items") ) { load_map_bash_item_drop_list(j.get_array("items"), items); } return true; } else { return false; } }
static void parse_vp_reqs( JsonObject &obj, const std::string &id, const std::string &key, std::vector<std::pair<requirement_id, int>> &reqs, std::map<skill_id, int> &skills, int &moves ) { if( !obj.has_object( key ) ) { return; } auto src = obj.get_object( key ); auto sk = src.get_array( "skills" ); if( !sk.empty() ) { skills.clear(); } while( sk.has_more() ) { auto cur = sk.next_array(); skills.emplace( skill_id( cur.get_string( 0 ) ), cur.size() >= 2 ? cur.get_int( 1 ) : 1 ); } assign( src, "time", moves ); if( src.has_string( "using" ) ) { reqs = { { requirement_id( src.get_string( "using" ) ), 1 } }; } else if( src.has_array( "using" ) ) { auto arr = src.get_array( "using" ); while( arr.has_more() ) { auto cur = arr.next_array(); reqs.emplace_back( requirement_id( cur.get_string( 0 ) ), cur.get_int( 1 ) ); } } else { const requirement_id req_id( string_format( "inline_%s_%s", key.c_str(), id.c_str() ) ); requirement_data::load_requirement( src, req_id ); reqs = { { req_id, 1 } }; } }
bool map_bash_info::load(JsonObject &jsobj, std::string member, bool isfurniture) { if( jsobj.has_object(member) ) { JsonObject j = jsobj.get_object(member); if ( jsonint(j, "num_tests", num_tests ) == false ) { if ( jsonint(j, "str_min", str_min ) && jsonint(j, "str_max", str_max ) ) { num_tests = 1; } } else if ( num_tests > 0 ) { str_min = j.get_int("str_min"); str_max = j.get_int("str_max"); } jsonint(j, "str_min_blocked", str_min_blocked ); jsonint(j, "str_max_blocked", str_max_blocked ); jsonint(j, "str_min_roll", str_min_roll ); jsonint(j, "explosive", explosive ); jsonint(j, "chance", chance ); jsonstring(j, "sound", sound ); jsonstring(j, "sound_fail", sound_fail ); jsonstring(j, "furn_set", furn_set ); if ( jsonstring(j, "ter_set", ter_set ) == false && isfurniture == false ) { ter_set = "t_rubble"; debugmsg("terrain[\"%s\"].bash.ter_set is not set!",jsobj.get_string("id").c_str() ); } if ( j.has_array("items") ) { load_map_bash_item_drop_list(j.get_array("items"), items); } //debugmsg("%d/%d %s %s/%s %d",str_min,str_max, ter_set.c_str(), sound.c_str(), sound_fail.c_str(), items.size() ); return true; } else { return false; } }
void fault::load_fault( JsonObject &jo ) { fault f; f.id_ = fault_id( jo.get_string( "id" ) ); f.name_ = _( jo.get_string( "name" ).c_str() ); f.description_ = _( jo.get_string( "description" ).c_str() ); auto sk = jo.get_array( "skills" ); while( sk.has_more() ) { auto cur = sk.next_array(); f.skills_.emplace( skill_id( cur.get_string( 0 ) ) , cur.size() >= 2 ? cur.get_int( 1 ) : 1 ); } auto req = jo.get_object( "requirements" ); f.requirements_.load( req ); if( faults_all.find( f.id_ ) != faults_all.end() ) { jo.throw_error( "parsed fault overwrites existing definition", "id" ); } else { faults_all[ f.id_ ] = f; DebugLog( D_INFO, DC_ALL ) << "Loaded fault: " << f.name_; } }
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, //otherwise we assume "name" is a string and use its value for prof._name if(jsobj.has_object("name")) { JsonObject name_obj=jsobj.get_object("name"); prof._name_male = _(name_obj.get_string("male").c_str()); prof._name_female = _(name_obj.get_string("female").c_str()); prof._name = ""; } else { // Json only has a gender neutral name, construct additional // gender specific names using a prefix. // extract_json_strings.py contains code that automatically adds // these constructed strings to the translation table. const std::string name = jsobj.get_string("name"); const std::string name_female = std::string("female ") + name; const std::string name_male = std::string("male ") + name; // Now attempt to translate them... prof._name = _(name.c_str()); prof._name_female = _(name_female.c_str()); prof._name_male = _(name_male.c_str()); // ... if it fails, translate the gender prefix and use it to // construct generic specific names: if (prof._name_female == name_female) { //~ player info: "female <gender unspecific profession>" prof._name_female = string_format(_("female %s"), prof._name.c_str()); } if (prof._name_male == name_male) { //~ player info: "male <gender unspecific profession>" prof._name_male = string_format(_("male %s"), prof._name.c_str()); } } prof._description = _(jsobj.get_string("description").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; //dout(D_INFO) << "Loaded profession: " << prof._name; }
void mtype::load( JsonObject &jo ) { MonsterGenerator &gen = MonsterGenerator::generator(); // Name and name plural are not translated here, but when needed in // combination with the actual count in `mtype::nname`. mandatory( jo, was_loaded, "name", name ); // default behaviour: Assume the regular plural form (appending an “s”) optional( jo, was_loaded, "name_plural", name_plural, name + "s" ); mandatory( jo, was_loaded, "description", description, translated_string_reader ); // Have to overwrite the default { "hflesh" } here if( !was_loaded || jo.has_member( "material" ) ) { mat = { jo.get_string( "material" ) }; } optional( jo, was_loaded, "species", species, auto_flags_reader<species_id> {} ); optional( jo, was_loaded, "categories", categories, auto_flags_reader<> {} ); // See monfaction.cpp if( !was_loaded || jo.has_member( "default_faction" ) ) { const auto faction = mfaction_str_id( jo.get_string( "default_faction" ) ); default_faction = monfactions::get_or_add_faction( faction ); } if( !was_loaded || jo.has_member( "symbol" ) ) { sym = jo.get_string( "symbol" ); if( utf8_wrapper( sym ).display_width() != 1 ) { jo.throw_error( "monster symbol should be exactly one console cell width", "symbol" ); } } mandatory( jo, was_loaded, "color", color, color_reader{} ); const typed_flag_reader<decltype( Creature::size_map )> size_reader{ Creature::size_map, "invalid creature size" }; optional( jo, was_loaded, "size", size, size_reader, MS_MEDIUM ); const typed_flag_reader<decltype( gen.phase_map )> phase_reader{ gen.phase_map, "invalid phase id" }; optional( jo, was_loaded, "phase", phase, phase_reader, SOLID ); optional( jo, was_loaded, "diff", difficulty, 0 ); optional( jo, was_loaded, "aggression", agro, 0 ); optional( jo, was_loaded, "morale", morale, 0 ); optional( jo, was_loaded, "speed", speed, 0 ); optional( jo, was_loaded, "attack_cost", attack_cost, 100 ); optional( jo, was_loaded, "melee_skill", melee_skill, 0 ); optional( jo, was_loaded, "melee_dice", melee_dice, 0 ); optional( jo, was_loaded, "melee_dice_sides", melee_sides, 0 ); optional( jo, was_loaded, "melee_cut", melee_cut, 0 ); optional( jo, was_loaded, "dodge", sk_dodge, 0 ); optional( jo, was_loaded, "armor_bash", armor_bash, 0 ); optional( jo, was_loaded, "armor_cut", armor_cut, 0 ); optional( jo, was_loaded, "armor_acid", armor_acid, armor_cut / 2 ); optional( jo, was_loaded, "armor_fire", armor_fire, 0 ); optional( jo, was_loaded, "hp", hp, 0 ); optional( jo, was_loaded, "starting_ammo", starting_ammo ); optional( jo, was_loaded, "luminance", luminance, 0 ); optional( jo, was_loaded, "revert_to_itype", revert_to_itype, "" ); optional( jo, was_loaded, "vision_day", vision_day, 40 ); optional( jo, was_loaded, "vision_night", vision_night, 1 ); optional( jo, was_loaded, "armor_stab", armor_stab, 0.8f * armor_cut ); // TODO: allow adding/removing specific entries if `was_loaded` is true if( jo.has_array( "attack_effs" ) ) { JsonArray jsarr = jo.get_array( "attack_effs" ); while( jsarr.has_more() ) { JsonObject e = jsarr.next_object(); mon_effect_data new_eff( efftype_id( e.get_string( "id" ) ), e.get_int( "duration", 0 ), get_body_part_token( e.get_string( "bp", "NUM_BP" ) ), e.get_bool( "permanent", false ), e.get_int( "chance", 100 ) ); atk_effs.push_back( new_eff ); } } if( jo.has_member( "death_drops" ) ) { JsonIn &stream = *jo.get_raw( "death_drops" ); death_drops = item_group::load_item_group( stream, "distribution" ); } const typed_flag_reader<decltype( gen.death_map )> death_reader{ gen.death_map, "invalid monster death function" }; optional( jo, was_loaded, "death_function", dies, death_reader ); if( dies.empty() ) { // TODO: really needed? Is an empty `dies` container not allowed? dies.push_back( mdeath::normal ); } // TODO: allow overriding/adding/removing those if `was_loaded` is true gen.load_special_defense( this, jo, "special_when_hit" ); gen.load_special_attacks( this, jo, "special_attacks" ); // Disable upgrading when JSON contains `"upgrades": false`, but fallback to the // normal behavior (including error checking) if "upgrades" is not boolean or not `false`. if( jo.has_bool( "upgrades" ) && !jo.get_bool( "upgrades" ) ) { upgrade_group = mongroup_id::NULL_ID; upgrade_into = mtype_id::NULL_ID; upgrades = false; } else if( jo.has_member( "upgrades" ) ) { JsonObject up = jo.get_object( "upgrades" ); optional( up, was_loaded, "half_life", half_life, -1 ); optional( up, was_loaded, "into_group", upgrade_group, auto_flags_reader<mongroup_id> {}, mongroup_id::NULL_ID ); optional( up, was_loaded, "into", upgrade_into, auto_flags_reader<mtype_id> {}, mtype_id::NULL_ID ); upgrades = true; } const typed_flag_reader<decltype( gen.flag_map )> flag_reader{ gen.flag_map, "invalid monster flag" }; optional( jo, was_loaded, "flags", flags, flag_reader ); const typed_flag_reader<decltype( gen.trigger_map )> trigger_reader{ gen.trigger_map, "invalid monster trigger" }; optional( jo, was_loaded, "anger_triggers", anger, trigger_reader ); optional( jo, was_loaded, "placate_triggers", placate, trigger_reader ); optional( jo, was_loaded, "fear_triggers", fear, trigger_reader ); }
void mtype::load( JsonObject &jo ) { MonsterGenerator &gen = MonsterGenerator::generator(); // Name and name plural are not translated here, but when needed in // combination with the actual count in `mtype::nname`. mandatory( jo, was_loaded, "name", name ); // default behaviour: Assume the regular plural form (appending an “s”) optional( jo, was_loaded, "name_plural", name_plural, name + "s" ); mandatory( jo, was_loaded, "description", description, translated_string_reader ); optional( jo, was_loaded, "material", mat, auto_flags_reader<material_id> {} ); optional( jo, was_loaded, "species", species, auto_flags_reader<species_id> {} ); optional( jo, was_loaded, "categories", categories, auto_flags_reader<> {} ); // See monfaction.cpp if( !was_loaded || jo.has_member( "default_faction" ) ) { const auto faction = mfaction_str_id( jo.get_string( "default_faction" ) ); default_faction = monfactions::get_or_add_faction( faction ); } if( !was_loaded || jo.has_member( "symbol" ) ) { sym = jo.get_string( "symbol" ); if( utf8_wrapper( sym ).display_width() != 1 ) { jo.throw_error( "monster symbol should be exactly one console cell width", "symbol" ); } } mandatory( jo, was_loaded, "color", color, color_reader{} ); const typed_flag_reader<decltype( Creature::size_map )> size_reader{ Creature::size_map, "invalid creature size" }; optional( jo, was_loaded, "size", size, size_reader, MS_MEDIUM ); const typed_flag_reader<decltype( gen.phase_map )> phase_reader{ gen.phase_map, "invalid phase id" }; optional( jo, was_loaded, "phase", phase, phase_reader, SOLID ); optional( jo, was_loaded, "diff", difficulty, 0 ); optional( jo, was_loaded, "aggression", agro, 0 ); optional( jo, was_loaded, "morale", morale, 0 ); optional( jo, was_loaded, "speed", speed, 0 ); optional( jo, was_loaded, "attack_cost", attack_cost, 100 ); optional( jo, was_loaded, "melee_skill", melee_skill, 0 ); optional( jo, was_loaded, "melee_dice", melee_dice, 0 ); optional( jo, was_loaded, "melee_dice_sides", melee_sides, 0 ); optional( jo, was_loaded, "dodge", sk_dodge, 0 ); optional( jo, was_loaded, "armor_bash", armor_bash, 0 ); optional( jo, was_loaded, "armor_cut", armor_cut, 0 ); optional( jo, was_loaded, "armor_acid", armor_acid, armor_cut / 2 ); optional( jo, was_loaded, "armor_fire", armor_fire, 0 ); optional( jo, was_loaded, "hp", hp, 0 ); optional( jo, was_loaded, "starting_ammo", starting_ammo ); optional( jo, was_loaded, "luminance", luminance, 0 ); optional( jo, was_loaded, "revert_to_itype", revert_to_itype, "" ); optional( jo, was_loaded, "vision_day", vision_day, 40 ); optional( jo, was_loaded, "vision_night", vision_night, 1 ); optional( jo, was_loaded, "armor_stab", armor_stab, 0.8f * armor_cut ); optional( jo, was_loaded, "attack_effs", atk_effs, mon_attack_effect_reader{} ); // TODO: make this work with `was_loaded` if( jo.has_array( "melee_damage" ) ) { JsonArray arr = jo.get_array( "melee_damage" ); melee_damage = load_damage_instance( arr ); } else if( jo.has_object( "melee_damage" ) ) { melee_damage = load_damage_instance( jo ); } if( jo.has_int( "melee_cut" ) ) { int bonus_cut = jo.get_int( "melee_cut" ); melee_damage.add_damage( DT_CUT, bonus_cut ); } if( jo.has_member( "death_drops" ) ) { JsonIn &stream = *jo.get_raw( "death_drops" ); death_drops = item_group::load_item_group( stream, "distribution" ); } const typed_flag_reader<decltype( gen.death_map )> death_reader{ gen.death_map, "invalid monster death function" }; optional( jo, was_loaded, "death_function", dies, death_reader ); if( dies.empty() ) { // TODO: really needed? Is an empty `dies` container not allowed? dies.push_back( mdeath::normal ); } if( jo.has_member( "special_when_hit" ) ) { JsonArray jsarr = jo.get_array( "special_when_hit" ); const auto iter = gen.defense_map.find( jsarr.get_string( 0 ) ); if( iter == gen.defense_map.end() ) { jsarr.throw_error( "Invalid monster defense function" ); } sp_defense = iter->second; def_chance = jsarr.get_int( 1 ); } else if( !was_loaded ) { sp_defense = &mdefense::none; def_chance = 0; } if( !was_loaded || jo.has_member( "special_attacks" ) ) { special_attacks.clear(); special_attacks_names.clear(); add_special_attacks( jo, "special_attacks" ); } else { // Note: special_attacks left as is, new attacks are added to it! // Note: member name prefixes are compatible with those used by generic_typed_reader remove_special_attacks( jo, "remove:special_attacks" ); add_special_attacks( jo, "add:special_attacks" ); } // Disable upgrading when JSON contains `"upgrades": false`, but fallback to the // normal behavior (including error checking) if "upgrades" is not boolean or not `false`. if( jo.has_bool( "upgrades" ) && !jo.get_bool( "upgrades" ) ) { upgrade_group = mongroup_id::NULL_ID; upgrade_into = mtype_id::NULL_ID; upgrades = false; } else if( jo.has_member( "upgrades" ) ) { JsonObject up = jo.get_object( "upgrades" ); optional( up, was_loaded, "half_life", half_life, -1 ); optional( up, was_loaded, "into_group", upgrade_group, auto_flags_reader<mongroup_id> {}, mongroup_id::NULL_ID ); optional( up, was_loaded, "into", upgrade_into, auto_flags_reader<mtype_id> {}, mtype_id::NULL_ID ); upgrades = true; } optional( jo, was_loaded, "burn_into", burn_into, auto_flags_reader<mtype_id> {}, mtype_id::NULL_ID ); const typed_flag_reader<decltype( gen.flag_map )> flag_reader{ gen.flag_map, "invalid monster flag" }; optional( jo, was_loaded, "flags", flags, flag_reader ); const typed_flag_reader<decltype( gen.trigger_map )> trigger_reader{ gen.trigger_map, "invalid monster trigger" }; optional( jo, was_loaded, "anger_triggers", anger, trigger_reader ); optional( jo, was_loaded, "placate_triggers", placate, trigger_reader ); optional( jo, was_loaded, "fear_triggers", fear, trigger_reader ); }
void npc_class::load( JsonObject &jo, const std::string & ) { mandatory( jo, was_loaded, "name", name, translated_string_reader ); mandatory( jo, was_loaded, "job_description", job_description, translated_string_reader ); optional( jo, was_loaded, "common", common, true ); bonus_str = load_distribution( jo, "bonus_str" ); bonus_dex = load_distribution( jo, "bonus_dex" ); bonus_int = load_distribution( jo, "bonus_int" ); bonus_per = load_distribution( jo, "bonus_per" ); optional( jo, was_loaded, "shopkeeper_item_group", shopkeeper_item_group, "EMPTY_GROUP" ); optional( jo, was_loaded, "worn_override", worn_override ); optional( jo, was_loaded, "carry_override", carry_override ); optional( jo, was_loaded, "weapon_override", weapon_override ); if( jo.has_array( "traits" ) ) { traits = trait_group::load_trait_group( *jo.get_raw( "traits" ), "collection" ); } /* Mutation rounds can be specified as follows: * "mutation_rounds": { * "ANY" : { "constant": 1 }, * "INSECT" : { "rng": [1, 3] } * } */ if( jo.has_object( "mutation_rounds" ) ) { const std::map<std::string, mutation_category_trait> &mutation_categories = mutation_category_trait::get_all(); auto jo2 = jo.get_object( "mutation_rounds" ); for( auto &mutation : jo2.get_member_names() ) { auto category_match = [&mutation]( std::pair<const std::string, mutation_category_trait> p ) { return p.second.id == mutation; }; if( std::find_if( mutation_categories.begin(), mutation_categories.end(), category_match ) == mutation_categories.end() ) { debugmsg( "Unrecognized mutation category %s", mutation ); continue; } auto distrib = jo2.get_object( mutation ); mutation_rounds[mutation] = load_distribution( distrib ); } } if( jo.has_array( "skills" ) ) { JsonArray jarr = jo.get_array( "skills" ); while( jarr.has_more() ) { JsonObject skill_obj = jarr.next_object(); auto skill_ids = skill_obj.get_tags( "skill" ); if( skill_obj.has_object( "level" ) ) { distribution dis = load_distribution( skill_obj, "level" ); for( const auto &sid : skill_ids ) { skills[ skill_id( sid ) ] = dis; } } else { distribution dis = load_distribution( skill_obj, "bonus" ); for( const auto &sid : skill_ids ) { bonus_skills[ skill_id( sid ) ] = dis; } } } } }
void player::json_load_common_variables(JsonObject & data) { JsonArray parray; // todo/maybe: // std::map<std::string, int*> strmap_common_variables; // void player::init_strmap_common_variables() { // strmap_common_variables["posx"]=&posx; // + all this below and in save_common_variables // } // load: // for(std::map<std::string, int*>::iterator it... // data.read(it->first,it->second); // save: // for(... // json.member( it->first, it->second ); if(!data.read("posx",posx) ) { // uh-oh. debugmsg("BAD PLAYER/NPC JSON: no 'posx'?"); } data.read("posy",posy); data.read("str_cur",str_cur); data.read("str_max",str_max); data.read("dex_cur",dex_cur); data.read("dex_max",dex_max); data.read("int_cur",int_cur); data.read("int_max",int_max); data.read("per_cur",per_cur); data.read("per_max",per_max); data.read("hunger",hunger); data.read("thirst",thirst); data.read("fatigue",fatigue); data.read("stim",stim); data.read("pain",pain); data.read("pkill",pkill); data.read("radiation",radiation); data.read("scent",scent); data.read("moves",moves); data.read("dodges_left",num_dodges); data.read("underwater",underwater); data.read("oxygen",oxygen); data.read("male",male); data.read("cash",cash); data.read("recoil",recoil); parray = data.get_array("hp_cur"); if ( parray.size() == num_hp_parts ) { for(int i=0; i < num_hp_parts; i++) { hp_cur[i] = parray.get_int(i); } } else { debugmsg("Error, incompatible hp_cur in save file '%s'",parray.str().c_str()); } parray = data.get_array("hp_max"); if ( parray.size() == num_hp_parts ) { for(int i=0; i < num_hp_parts; i++) { hp_max[i] = parray.get_int(i); } } else { debugmsg("Error, incompatible hp_max in save file '%s'",parray.str().c_str()); } data.read("power_level",power_level); data.read("max_power_level",max_power_level); data.read("traits",my_traits); if (data.has_object("skills")) { JsonObject pmap = data.get_object("skills"); for (std::vector<Skill*>::iterator aSkill = Skill::skills.begin(); aSkill != Skill::skills.end(); ++aSkill) { if ( pmap.has_object( (*aSkill)->ident() ) ) { pmap.read( (*aSkill)->ident(), skillLevel(*aSkill) ); } else { debugmsg("Load (%s) Missing skill %s","",(*aSkill)->ident().c_str() ); } } } else { debugmsg("Skills[] no bueno"); } data.read("ma_styles",ma_styles); data.read("illness",illness); data.read("effects",effects); data.read("addictions",addictions); data.read("my_bionics",my_bionics); }
void MonsterGenerator::load_monster(JsonObject &jo) { // id std::string mid; if (jo.has_member("id")) { mid = jo.get_string("id"); if (mon_templates.count(mid) > 0) { delete mon_templates[mid]; } mtype *newmon = new mtype; newmon->id = mid; newmon->name = jo.get_string("name").c_str(); if(jo.has_member("name_plural")) { newmon->name_plural = jo.get_string("name_plural"); } else { // default behaviour: Assume the regular plural form (appending an “s”) newmon->name_plural = newmon->name + "s"; } newmon->description = _(jo.get_string("description").c_str()); newmon->mat = jo.get_string("material"); newmon->species = jo.get_tags("species"); newmon->categories = jo.get_tags("categories"); newmon->sym = jo.get_string("symbol"); if( utf8_wrapper( newmon->sym ).display_width() != 1 ) { jo.throw_error( "monster symbol should be exactly one console cell width", "symbol" ); } newmon->color = color_from_string(jo.get_string("color")); newmon->size = get_from_string(jo.get_string("size", "MEDIUM"), size_map, MS_MEDIUM); newmon->phase = get_from_string(jo.get_string("phase", "SOLID"), phase_map, SOLID); newmon->difficulty = jo.get_int("diff", 0); newmon->agro = jo.get_int("aggression", 0); newmon->morale = jo.get_int("morale", 0); newmon->speed = jo.get_int("speed", 0); newmon->melee_skill = jo.get_int("melee_skill", 0); newmon->melee_dice = jo.get_int("melee_dice", 0); newmon->melee_sides = jo.get_int("melee_dice_sides", 0); newmon->melee_cut = jo.get_int("melee_cut", 0); newmon->sk_dodge = jo.get_int("dodge", 0); newmon->armor_bash = jo.get_int("armor_bash", 0); newmon->armor_cut = jo.get_int("armor_cut", 0); newmon->hp = jo.get_int("hp", 0); jo.read("starting_ammo", newmon->starting_ammo); newmon->luminance = jo.get_float("luminance", 0); newmon->revert_to_itype = jo.get_string( "revert_to_itype", "" ); if (jo.has_array("attack_effs")) { JsonArray jsarr = jo.get_array("attack_effs"); while (jsarr.has_more()) { JsonObject e = jsarr.next_object(); mon_effect_data new_eff(e.get_string("id", "null"), e.get_int("duration", 0), body_parts[e.get_string("bp", "NUM_BP")], e.get_bool("permanent", false), e.get_int("chance", 100)); newmon->atk_effs.push_back(new_eff); } } if (jo.has_string("death_drops")) { newmon->death_drops = jo.get_string("death_drops"); } else if (jo.has_object("death_drops")) { JsonObject death_frop_json = jo.get_object("death_drops"); // Make up a group name, should be unique (include the monster id), newmon->death_drops = newmon->id + "_death_drops_auto"; const std::string subtype = death_frop_json.get_string("subtype", "distribution"); // and load the entry as a standard item group using the made up name. item_group::load_item_group(death_frop_json, newmon->death_drops, subtype); } else if (jo.has_member("death_drops")) { jo.throw_error("invalid type, must be string or object", "death_drops"); } newmon->dies = get_death_functions(jo, "death_function"); load_special_defense(newmon, jo, "special_when_hit"); load_special_attacks(newmon, jo, "special_attacks"); std::set<std::string> flags, anger_trig, placate_trig, fear_trig; flags = jo.get_tags("flags"); anger_trig = jo.get_tags("anger_triggers"); placate_trig = jo.get_tags("placate_triggers"); fear_trig = jo.get_tags("fear_triggers"); newmon->flags = get_set_from_tags(flags, flag_map, MF_NULL); newmon->anger = get_set_from_tags(anger_trig, trigger_map, MTRIG_NULL); newmon->fear = get_set_from_tags(fear_trig, trigger_map, MTRIG_NULL); newmon->placate = get_set_from_tags(placate_trig, trigger_map, MTRIG_NULL); mon_templates[mid] = newmon; } }
/** * Reads in a vehicle part from a JsonObject. */ void vpart_info::load( JsonObject &jo, const std::string &src ) { vpart_info def; if( jo.has_string( "copy-from" ) ) { auto const base = vpart_info_all.find( vpart_id( jo.get_string( "copy-from" ) ) ); auto const ab = abstract_parts.find( vpart_id( jo.get_string( "copy-from" ) ) ); if( base != vpart_info_all.end() ) { def = base->second; } else if( ab != abstract_parts.end() ) { def = ab->second; } else { deferred.emplace_back( jo.str(), src ); return; } } if( jo.has_string( "abstract" ) ) { def.id = vpart_id( jo.get_string( "abstract" ) ); } else { def.id = vpart_id( jo.get_string( "id" ) ); } assign( jo, "name", def.name_ ); assign( jo, "item", def.item ); assign( jo, "location", def.location ); assign( jo, "durability", def.durability ); assign( jo, "damage_modifier", def.dmg_mod ); assign( jo, "power", def.power ); assign( jo, "epower", def.epower ); assign( jo, "fuel_type", def.fuel_type ); assign( jo, "default_ammo", def.default_ammo ); assign( jo, "folded_volume", def.folded_volume ); assign( jo, "size", def.size ); assign( jo, "difficulty", def.difficulty ); assign( jo, "bonus", def.bonus ); assign( jo, "flags", def.flags ); if( jo.has_member( "requirements" ) ) { auto reqs = jo.get_object( "requirements" ); parse_vp_reqs( reqs, def.id.str(), "install", def.install_reqs, def.install_skills, def.install_moves ); parse_vp_reqs( reqs, def.id.str(), "removal", def.removal_reqs, def.removal_skills, def.removal_moves ); parse_vp_reqs( reqs, def.id.str(), "repair", def.repair_reqs, def.repair_skills, def.repair_moves ); def.legacy = false; } if( jo.has_member( "symbol" ) ) { def.sym = jo.get_string( "symbol" )[ 0 ]; } if( jo.has_member( "broken_symbol" ) ) { def.sym_broken = jo.get_string( "broken_symbol" )[ 0 ]; } if( jo.has_member( "color" ) ) { def.color = color_from_string( jo.get_string( "color" ) ); } if( jo.has_member( "broken_color" ) ) { def.color_broken = color_from_string( jo.get_string( "broken_color" ) ); } if( jo.has_member( "breaks_into" ) ) { JsonIn& stream = *jo.get_raw( "breaks_into" ); def.breaks_into_group = item_group::load_item_group( stream, "collection" ); } auto qual = jo.get_array( "qualities" ); if( !qual.empty() ) { def.qualities.clear(); while( qual.has_more() ) { auto pair = qual.next_array(); def.qualities[ quality_id( pair.get_string( 0 ) ) ] = pair.get_int( 1 ); } } if( jo.has_member( "damage_reduction" ) ) { JsonObject dred = jo.get_object( "damage_reduction" ); def.damage_reduction = load_damage_array( dred ); } else { def.damage_reduction.fill( 0.0f ); } if( jo.has_string( "abstract" ) ) { abstract_parts[def.id] = def; } else { vpart_info_all[def.id] = def; } }
void MonsterGenerator::load_monster(JsonObject &jo) { const mtype_id mid = mtype_id( jo.get_string("id") ); if (mon_templates.count(mid) > 0) { delete mon_templates[mid]; } mtype *newmon = new mtype; newmon->id = mid; newmon->name = jo.get_string("name").c_str(); if(jo.has_member("name_plural")) { newmon->name_plural = jo.get_string("name_plural"); } else { // default behaviour: Assume the regular plural form (appending an “s”) newmon->name_plural = newmon->name + "s"; } newmon->description = _(jo.get_string("description").c_str()); // Have to overwrite the default { "hflesh" } here newmon->mat = { jo.get_string("material") }; for( auto &s : jo.get_tags( "species" ) ) { newmon->species.insert( species_id( s ) ); } newmon->categories = jo.get_tags("categories"); // See monfaction.cpp newmon->default_faction = monfactions::get_or_add_faction( mfaction_str_id( jo.get_string("default_faction") ) ); newmon->sym = jo.get_string("symbol"); if( utf8_wrapper( newmon->sym ).display_width() != 1 ) { jo.throw_error( "monster symbol should be exactly one console cell width", "symbol" ); } newmon->color = color_from_string(jo.get_string("color")); newmon->size = get_from_string(jo.get_string("size", "MEDIUM"), Creature::size_map, MS_MEDIUM); newmon->phase = get_from_string(jo.get_string("phase", "SOLID"), phase_map, SOLID); newmon->difficulty = jo.get_int("diff", 0); newmon->agro = jo.get_int("aggression", 0); newmon->morale = jo.get_int("morale", 0); newmon->speed = jo.get_int("speed", 0); newmon->attack_cost = jo.get_int("attack_cost", 100); newmon->melee_skill = jo.get_int("melee_skill", 0); newmon->melee_dice = jo.get_int("melee_dice", 0); newmon->melee_sides = jo.get_int("melee_dice_sides", 0); newmon->melee_cut = jo.get_int("melee_cut", 0); newmon->sk_dodge = jo.get_int("dodge", 0); newmon->armor_bash = jo.get_int("armor_bash", 0); newmon->armor_cut = jo.get_int("armor_cut", 0); newmon->hp = jo.get_int("hp", 0); jo.read("starting_ammo", newmon->starting_ammo); newmon->luminance = jo.get_float("luminance", 0); newmon->revert_to_itype = jo.get_string( "revert_to_itype", "" ); newmon->vision_day = jo.get_int("vision_day", 40); newmon->vision_night = jo.get_int("vision_night", 1); if (jo.has_array("attack_effs")) { JsonArray jsarr = jo.get_array("attack_effs"); while (jsarr.has_more()) { JsonObject e = jsarr.next_object(); mon_effect_data new_eff(e.get_string("id", "null"), e.get_int("duration", 0), get_body_part_token( e.get_string("bp", "NUM_BP") ), e.get_bool("permanent", false), e.get_int("chance", 100)); newmon->atk_effs.push_back(new_eff); } } if( jo.has_member( "death_drops" ) ) { JsonIn& stream = *jo.get_raw( "death_drops" ); newmon->death_drops = item_group::load_item_group( stream, "distribution" ); } newmon->dies = get_death_functions(jo, "death_function"); load_special_defense(newmon, jo, "special_when_hit"); load_special_attacks(newmon, jo, "special_attacks"); if (jo.has_member("upgrades")) { JsonObject upgrades = jo.get_object("upgrades"); newmon->half_life = upgrades.get_int("half_life", -1); newmon->upgrade_group = mongroup_id( upgrades.get_string("into_group", mongroup_id::NULL_ID.str() ) ); newmon->upgrade_into = mtype_id( upgrades.get_string("into", mtype_id::NULL_ID.str() ) ); newmon->upgrades = true; } std::set<std::string> flags, anger_trig, placate_trig, fear_trig; flags = jo.get_tags("flags"); anger_trig = jo.get_tags("anger_triggers"); placate_trig = jo.get_tags("placate_triggers"); fear_trig = jo.get_tags("fear_triggers"); newmon->flags = get_set_from_tags(flags, flag_map, MF_NULL); newmon->anger = get_set_from_tags(anger_trig, trigger_map, MTRIG_NULL); newmon->fear = get_set_from_tags(fear_trig, trigger_map, MTRIG_NULL); newmon->placate = get_set_from_tags(placate_trig, trigger_map, MTRIG_NULL); mon_templates[mid] = newmon; }
/** * Reads in a vehicle part from a JsonObject. */ void vpart_info::load( JsonObject &jo, const std::string &src ) { vpart_info def; if( jo.has_string( "copy-from" ) ) { auto const base = vehicle_part_types.find( vpart_str_id( jo.get_string( "copy-from" ) ) ); auto const ab = abstract_parts.find( vpart_str_id( jo.get_string( "copy-from" ) ) ); if( base != vehicle_part_types.end() ) { def = base->second; } else if( ab != abstract_parts.end() ) { def = ab->second; } else { deferred.emplace_back( jo.str(), src ); } } if( jo.has_string( "abstract" ) ) { def.id = vpart_str_id( jo.get_string( "abstract" ) ); } else { def.id = vpart_str_id( jo.get_string( "id" ) ); } assign( jo, "name", def.name_ ); assign( jo, "item", def.item ); assign( jo, "location", def.location ); assign( jo, "durability", def.durability ); assign( jo, "damage_modifier", def.dmg_mod ); assign( jo, "power", def.power ); assign( jo, "epower", def.epower ); assign( jo, "fuel_type", def.fuel_type ); assign( jo, "folded_volume", def.folded_volume ); assign( jo, "size", def.size ); assign( jo, "difficulty", def.difficulty ); assign( jo, "bonus", def.bonus ); assign( jo, "flags", def.flags ); auto reqs = jo.get_object( "requirements" ); if( reqs.has_object( "install" ) ) { auto ins = reqs.get_object( "install" ); auto sk = ins.get_array( "skills" ); if( !sk.empty() ) { def.install_skills.clear(); } while( sk.has_more() ) { auto cur = sk.next_array(); def.install_skills.emplace( skill_id( cur.get_string( 0 ) ) , cur.size() >= 2 ? cur.get_int( 1 ) : 1 ); } assign( ins, "time", def.install_moves ); if( ins.has_string( "using" ) ) { def.install_reqs = { { requirement_id( ins.get_string( "using" ) ), 1 } }; } else if( ins.has_array( "using" ) ) { auto arr = ins.get_array( "using" ); while( arr.has_more() ) { auto cur = arr.next_array(); def.install_reqs.emplace_back( requirement_id( cur.get_string( 0 ) ), cur.get_int( 1 ) ); } } else { auto req_id = std::string( "inline_vehins_" ) += def.id.str(); requirement_data::load_requirement( ins, req_id ); def.install_reqs = { { requirement_id( req_id ), 1 } }; } def.legacy = false; } if( reqs.has_object( "removal" ) ) { auto rem = reqs.get_object( "removal" ); auto sk = rem.get_array( "skills" ); if( !sk.empty() ) { def.removal_skills.clear(); } while( sk.has_more() ) { auto cur = sk.next_array(); def.removal_skills.emplace( skill_id( cur.get_string( 0 ) ) , cur.size() >= 2 ? cur.get_int( 1 ) : 1 ); } assign( rem, "time", def.removal_moves ); if( rem.has_string( "using" ) ) { def.removal_reqs = { { requirement_id( rem.get_string( "using" ) ), 1 } }; } else if( rem.has_array( "using" ) ) { auto arr = rem.get_array( "using" ); while( arr.has_more() ) { auto cur = arr.next_array(); def.removal_reqs.emplace_back( requirement_id( cur.get_string( 0 ) ), cur.get_int( 1 ) ); } } else { auto req_id = std::string( "inline_vehins_" ) += def.id.str(); requirement_data::load_requirement( rem, req_id ); def.removal_reqs = { { requirement_id( req_id ), 1 } }; } def.legacy = false; } if( jo.has_member( "symbol" ) ) { def.sym = jo.get_string( "symbol" )[ 0 ]; } if( jo.has_member( "broken_symbol" ) ) { def.sym_broken = jo.get_string( "broken_symbol" )[ 0 ]; } if( jo.has_member( "color" ) ) { def.color = color_from_string( jo.get_string( "color" ) ); } if( jo.has_member( "broken_color" ) ) { def.color_broken = color_from_string( jo.get_string( "broken_color" ) ); } if( jo.has_member( "breaks_into" ) ) { JsonIn& stream = *jo.get_raw( "breaks_into" ); def.breaks_into_group = item_group::load_item_group( stream, "collection" ); } auto qual = jo.get_array( "qualities" ); if( !qual.empty() ) { def.qualities.clear(); while( qual.has_more() ) { auto pair = qual.next_array(); def.qualities[ quality_id( pair.get_string( 0 ) ) ] = pair.get_int( 1 ); } } if( jo.has_member( "damage_reduction" ) ) { JsonObject dred = jo.get_object( "damage_reduction" ); def.damage_reduction = load_damage_array( dred ); } else { def.damage_reduction.fill( 0.0f ); } if( jo.has_string( "abstract" ) ) { abstract_parts[ def.id ] = def; return; } auto const iter = vehicle_part_types.find( def.id ); if( iter != vehicle_part_types.end() ) { // Entry in the map already exists, so the pointer in the vector is already correct // and does not need to be changed, only the int-id needs to be taken from the old entry. def.loadid = iter->second.loadid; iter->second = def; } else { // The entry is new, "generate" a new int-id and link the new entry from the vector. def.loadid = vpart_id( vehicle_part_int_types.size() ); vpart_info &new_entry = vehicle_part_types[ def.id ]; new_entry = def; vehicle_part_int_types.push_back( &new_entry ); } }
void mutation_branch::load( JsonObject &jo, const std::string & ) { mandatory( jo, was_loaded, "id", id ); mandatory( jo, was_loaded, "name", raw_name, translated_string_reader ); mandatory( jo, was_loaded, "description", raw_desc, translated_string_reader ); mandatory( jo, was_loaded, "points", points ); optional( jo, was_loaded, "visibility", visibility, 0 ); optional( jo, was_loaded, "ugliness", ugliness, 0 ); optional( jo, was_loaded, "starting_trait", startingtrait, false ); optional( jo, was_loaded, "mixed_effect", mixed_effect, false ); optional( jo, was_loaded, "active", activated, false ); optional( jo, was_loaded, "starts_active", starts_active, false ); optional( jo, was_loaded, "destroys_gear", destroys_gear, false ); optional( jo, was_loaded, "allow_soft_gear", allow_soft_gear, false ); optional( jo, was_loaded, "cost", cost, 0 ); optional( jo, was_loaded, "time", cooldown, 0 ); optional( jo, was_loaded, "hunger", hunger, false ); optional( jo, was_loaded, "thirst", thirst, false ); optional( jo, was_loaded, "fatigue", fatigue, false ); optional( jo, was_loaded, "valid", valid, true ); optional( jo, was_loaded, "purifiable", purifiable, true ); if( jo.has_object( "spawn_item" ) ) { auto si = jo.get_object( "spawn_item" ); optional( si, was_loaded, "type", spawn_item ); optional( si, was_loaded, "message", raw_spawn_item_message ); } if( jo.has_object( "ranged_mutation" ) ) { auto si = jo.get_object( "ranged_mutation" ); optional( si, was_loaded, "type", ranged_mutation ); optional( si, was_loaded, "message", raw_ranged_mutation_message ); } optional( jo, was_loaded, "initial_ma_styles", initial_ma_styles ); if( jo.has_array( "bodytemp_modifiers" ) ) { auto bodytemp_array = jo.get_array( "bodytemp_modifiers" ); bodytemp_min = bodytemp_array.get_int( 0 ); bodytemp_max = bodytemp_array.get_int( 1 ); } optional( jo, was_loaded, "bodytemp_sleep", bodytemp_sleep, 0 ); optional( jo, was_loaded, "threshold", threshold, false ); optional( jo, was_loaded, "profession", profession, false ); optional( jo, was_loaded, "debug", debug, false ); optional( jo, was_loaded, "player_display", player_display, true ); JsonArray vr = jo.get_array( "vitamin_rates" ); while( vr.has_more() ) { auto pair = vr.next_array(); vitamin_rates.emplace( vitamin_id( pair.get_string( 0 ) ), time_duration::from_turns( pair.get_int( 1 ) ) ); } auto vam = jo.get_array( "vitamins_absorb_multi" ); while( vam.has_more() ) { auto pair = vam.next_array(); std::map<vitamin_id, double> vit; auto vit_array = pair.get_array( 1 ); // fill the inner map with vitamins while( vit_array.has_more() ) { auto vitamins = vit_array.next_array(); vit.emplace( vitamin_id( vitamins.get_string( 0 ) ), vitamins.get_float( 1 ) ); } // assign the inner vitamin map to the material_id key vitamin_absorb_multi.emplace( material_id( pair.get_string( 0 ) ), vit ); } optional( jo, was_loaded, "healing_awake", healing_awake, 0.0f ); optional( jo, was_loaded, "healing_resting", healing_resting, 0.0f ); optional( jo, was_loaded, "hp_modifier", hp_modifier, 0.0f ); optional( jo, was_loaded, "hp_modifier_secondary", hp_modifier_secondary, 0.0f ); optional( jo, was_loaded, "hp_adjustment", hp_adjustment, 0.0f ); optional( jo, was_loaded, "stealth_modifier", stealth_modifier, 0.0f ); optional( jo, was_loaded, "str_modifier", str_modifier, 0.0f ); optional( jo, was_loaded, "dodge_modifier", dodge_modifier, 0.0f ); optional( jo, was_loaded, "speed_modifier", speed_modifier, 1.0f ); optional( jo, was_loaded, "movecost_modifier", movecost_modifier, 1.0f ); optional( jo, was_loaded, "movecost_flatground_modifier", movecost_flatground_modifier, 1.0f ); optional( jo, was_loaded, "movecost_obstacle_modifier", movecost_obstacle_modifier, 1.0f ); optional( jo, was_loaded, "attackcost_modifier", attackcost_modifier, 1.0f ); optional( jo, was_loaded, "max_stamina_modifier", max_stamina_modifier, 1.0f ); optional( jo, was_loaded, "weight_capacity_modifier", weight_capacity_modifier, 1.0f ); optional( jo, was_loaded, "hearing_modifier", hearing_modifier, 1.0f ); optional( jo, was_loaded, "noise_modifier", noise_modifier, 1.0f ); optional( jo, was_loaded, "metabolism_modifier", metabolism_modifier, 0.0f ); optional( jo, was_loaded, "thirst_modifier", thirst_modifier, 0.0f ); optional( jo, was_loaded, "fatigue_modifier", fatigue_modifier, 0.0f ); optional( jo, was_loaded, "fatigue_regen_modifier", fatigue_regen_modifier, 0.0f ); optional( jo, was_loaded, "stamina_regen_modifier", stamina_regen_modifier, 0.0f ); optional( jo, was_loaded, "overmap_sight", overmap_sight, 0.0f ); optional( jo, was_loaded, "overmap_multiplier", overmap_multiplier, 1.0f ); if( jo.has_object( "social_modifiers" ) ) { JsonObject sm = jo.get_object( "social_modifiers" ); social_mods = load_mutation_social_mods( sm ); } load_mutation_mods( jo, "passive_mods", mods ); /* Not currently supported due to inability to save active mutation state load_mutation_mods(jsobj, "active_mods", new_mut.mods); */ optional( jo, was_loaded, "prereqs", prereqs ); optional( jo, was_loaded, "prereqs2", prereqs2 ); optional( jo, was_loaded, "threshreq", threshreq ); optional( jo, was_loaded, "cancels", cancels ); optional( jo, was_loaded, "changes_to", replacements ); optional( jo, was_loaded, "leads_to", additions ); optional( jo, was_loaded, "flags", flags ); optional( jo, was_loaded, "types", types ); auto jsarr = jo.get_array( "category" ); while( jsarr.has_more() ) { std::string s = jsarr.next_string(); category.push_back( s ); mutations_category[s].push_back( trait_id( id ) ); } jsarr = jo.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 ); protection[get_body_part_token( part_id )] = protect; } jsarr = jo.get_array( "encumbrance_always" ); while( jsarr.has_more() ) { JsonArray jo = jsarr.next_array(); std::string part_id = jo.next_string(); int enc = jo.next_int(); encumbrance_always[get_body_part_token( part_id )] = enc; } jsarr = jo.get_array( "encumbrance_covered" ); while( jsarr.has_more() ) { JsonArray jo = jsarr.next_array(); std::string part_id = jo.next_string(); int enc = jo.next_int(); encumbrance_covered[get_body_part_token( part_id )] = enc; } jsarr = jo.get_array( "restricts_gear" ); while( jsarr.has_more() ) { restricts_gear.insert( get_body_part_token( jsarr.next_string() ) ); } jsarr = jo.get_array( "armor" ); while( jsarr.has_more() ) { JsonObject jo = jsarr.next_object(); auto parts = jo.get_tags( "parts" ); std::set<body_part> bps; for( const std::string &part_string : parts ) { if( part_string == "ALL" ) { // Shorthand, since many mutations protect whole body bps.insert( all_body_parts.begin(), all_body_parts.end() ); } else { bps.insert( get_body_part_token( part_string ) ); } } resistances res = load_resistances_instance( jo ); for( body_part bp : bps ) { armor[ bp ] = res; } } if( jo.has_array( "attacks" ) ) { jsarr = jo.get_array( "attacks" ); while( jsarr.has_more() ) { JsonObject jo = jsarr.next_object(); attacks_granted.emplace_back( load_mutation_attack( jo ) ); } } else if( jo.has_object( "attacks" ) ) { JsonObject attack = jo.get_object( "attacks" ); attacks_granted.emplace_back( load_mutation_attack( attack ) ); } }
void item::deserialize(JsonObject &data) { init(); clear(); std::string idtmp=""; std::string ammotmp="null"; int lettmp = 0; std::string corptmp = "null"; int damtmp = 0; if ( ! data.read( "typeid", idtmp) ) { debugmsg("Invalid item type: %s ", data.str().c_str() ); idtmp = "null"; } data.read( "charges", charges ); data.read( "burnt", burnt ); data.read( "poison", poison ); data.read( "owned", owned ); data.read( "bday", bday ); data.read( "mode", mode ); data.read( "mission_id", mission_id ); data.read( "player_id", player_id ); if (!data.read( "corpse", corptmp )) { int ctmp = -1; data.read( "corpse", ctmp ); if (ctmp != -1) { corptmp = legacy_mon_id[ctmp]; } else { corptmp = "null"; } } if (corptmp != "null") { corpse = GetMType(corptmp); } else { corpse = NULL; } JsonObject pvars = data.get_object("item_vars"); std::set<std::string> members = pvars.get_member_names(); for ( std::set<std::string>::iterator pvarsit = members.begin(); pvarsit != members.end(); ++pvarsit ) { if ( pvars.has_string( *pvarsit ) ) { item_vars[ *pvarsit ] = pvars.get_string( *pvarsit ); } } bool old_itype = false; if ( idtmp == "null" ) { std::map<std::string, std::string>::const_iterator oldity = item_vars.find("_invalid_itype_"); if ( oldity != item_vars.end() ) { old_itype = true; idtmp = oldity->second; } } std::map<std::string, itype*>::const_iterator ity = itypes.find(idtmp); if ( ity == itypes.end() ) { item_vars["_invalid_itype_"] = idtmp; make(NULL); } else { if ( old_itype ) { item_vars.erase( "_invalid_itype_" ); } make(ity->second); } if ( ! data.read( "name", name ) ) { name=type->name; } data.read( "invlet", lettmp ); invlet = char(lettmp); data.read( "damage", damtmp ); damage = damtmp; // todo: check why this is done after make(), using a tmp variable data.read( "active", active ); data.read( "item_counter" , item_counter ); data.read( "fridge", fridge ); data.read( "rot", rot ); data.read( "last_rot_check", last_rot_check ); data.read( "curammo", ammotmp ); if ( ammotmp != "null" ) { curammo = dynamic_cast<it_ammo*>(itypes[ammotmp]); } else { curammo = NULL; } data.read("item_tags", item_tags); int tmplum=0; if ( data.read("light",tmplum) ) { light=nolight; int tmpwidth=0; int tmpdir=0; data.read("light_width",tmpwidth); data.read("light_dir",tmpdir); light.luminance = tmplum; light.width = (short)tmpwidth; light.direction = (short)tmpdir; } data.read("contents", contents); data.read("components", components); }
bool map_bash_info::load(JsonObject &jsobj, std::string member, bool isfurniture) { if( jsobj.has_object(member) ) { JsonObject j = jsobj.get_object(member); if ( jsonint(j, "num_tests", num_tests ) == false ) { if ( jsonint(j, "str_min", str_min ) && jsonint(j, "str_max", str_max ) ) { num_tests = 1; } } else if ( num_tests > 0 ) { str_min = j.get_int("str_min"); str_max = j.get_int("str_max"); } jsonint(j, "str_min_blocked", str_min_blocked ); jsonint(j, "str_max_blocked", str_max_blocked ); jsonint(j, "str_min_roll", str_min_roll ); jsonint(j, "explosive", explosive ); jsonint(j, "chance", chance ); jsonstring(j, "sound", sound ); jsonstring(j, "sound_fail", sound_fail ); jsonstring(j, "furn_set", furn_set ); if ( jsonstring(j, "ter_set", ter_set ) == false && isfurniture == false ) { ter_set = "t_rubble"; debugmsg("terrain[\"%s\"].bash.ter_set is not set!",jsobj.get_string("id").c_str() ); } if ( j.has_array("items") ) { JsonArray ja = j.get_array("items"); if (ja.size() > 0) { int c=0; while ( ja.has_more() ) { if ( ja.has_object(c) ) { JsonObject jio = ja.next_object(); if ( jio.has_string("item") && jio.has_int("amount") ) { if ( jio.has_int("minamount") ) { map_bash_item_drop drop( jio.get_string("item"), jio.get_int("amount"), jio.get_int("minamount") ); jsonint(jio, "chance", drop.chance); items.push_back(drop); } else { map_bash_item_drop drop( jio.get_string("item"), jio.get_int("amount") ); jsonint(jio, "chance", drop.chance); items.push_back(drop); } } else { debugmsg("terrain[\"%s\"].bash.items[%d]: invalid entry",jsobj.get_string("id").c_str(),c); } } else { debugmsg("terrain[\"%s\"].bash.items[%d]: invalid entry",jsobj.get_string("id").c_str(),c); } c++; } } } //debugmsg("%d/%d %s %s/%s %d",str_min,str_max, ter_set.c_str(), sound.c_str(), sound_fail.c_str(), items.size() ); return true; } else { return false; } }
void mtype::load( JsonObject &jo, const std::string &src ) { bool strict = src == "dda"; MonsterGenerator &gen = MonsterGenerator::generator(); // Name and name plural are not translated here, but when needed in // combination with the actual count in `mtype::nname`. mandatory( jo, was_loaded, "name", name ); // default behavior: Assume the regular plural form (appending an “s”) optional( jo, was_loaded, "name_plural", name_plural, name + "s" ); optional( jo, was_loaded, "description", description ); optional( jo, was_loaded, "material", mat, auto_flags_reader<material_id> {} ); optional( jo, was_loaded, "species", species, auto_flags_reader<species_id> {} ); optional( jo, was_loaded, "categories", categories, auto_flags_reader<> {} ); // See monfaction.cpp if( !was_loaded || jo.has_member( "default_faction" ) ) { const auto faction = mfaction_str_id( jo.get_string( "default_faction" ) ); default_faction = monfactions::get_or_add_faction( faction ); } if( !was_loaded || jo.has_member( "symbol" ) ) { sym = jo.get_string( "symbol" ); if( utf8_wrapper( sym ).display_width() != 1 ) { jo.throw_error( "monster symbol should be exactly one console cell width", "symbol" ); } } if( was_loaded && jo.has_member( "copy-from" ) && looks_like.empty() ) { looks_like = jo.get_string( "copy-from" ); } if( jo.has_member( "looks_like" ) ) { looks_like = jo.get_string( "looks_like" ); } assign( jo, "color", color ); const typed_flag_reader<decltype( Creature::size_map )> size_reader{ Creature::size_map, "invalid creature size" }; optional( jo, was_loaded, "size", size, size_reader, MS_MEDIUM ); const typed_flag_reader<decltype( gen.phase_map )> phase_reader{ gen.phase_map, "invalid phase id" }; optional( jo, was_loaded, "phase", phase, phase_reader, SOLID ); assign( jo, "diff", difficulty, strict, 0 ); assign( jo, "hp", hp, strict, 1 ); assign( jo, "speed", speed, strict, 0 ); assign( jo, "aggression", agro, strict, -100, 100 ); assign( jo, "morale", morale, strict ); assign( jo, "attack_cost", attack_cost, strict, 0 ); assign( jo, "melee_skill", melee_skill, strict, 0 ); assign( jo, "melee_dice", melee_dice, strict, 0 ); assign( jo, "melee_dice_sides", melee_sides, strict, 0 ); assign( jo, "dodge", sk_dodge, strict, 0 ); assign( jo, "armor_bash", armor_bash, strict, 0 ); assign( jo, "armor_cut", armor_cut, strict, 0 ); assign( jo, "armor_stab", armor_stab, strict, 0 ); assign( jo, "armor_acid", armor_acid, strict, 0 ); assign( jo, "armor_fire", armor_fire, strict, 0 ); assign( jo, "vision_day", vision_day, strict, 0 ); assign( jo, "vision_night", vision_night, strict, 0 ); optional( jo, was_loaded, "starting_ammo", starting_ammo ); optional( jo, was_loaded, "luminance", luminance, 0 ); optional( jo, was_loaded, "revert_to_itype", revert_to_itype, "" ); optional( jo, was_loaded, "attack_effs", atk_effs, mon_attack_effect_reader{} ); // TODO: make this work with `was_loaded` if( jo.has_array( "melee_damage" ) ) { JsonArray arr = jo.get_array( "melee_damage" ); melee_damage = load_damage_instance( arr ); } else if( jo.has_object( "melee_damage" ) ) { melee_damage = load_damage_instance( jo ); } if( jo.has_int( "melee_cut" ) ) { int bonus_cut = jo.get_int( "melee_cut" ); melee_damage.add_damage( DT_CUT, bonus_cut ); } if( jo.has_member( "death_drops" ) ) { JsonIn &stream = *jo.get_raw( "death_drops" ); death_drops = item_group::load_item_group( stream, "distribution" ); } assign( jo, "harvest", harvest, strict ); const typed_flag_reader<decltype( gen.death_map )> death_reader{ gen.death_map, "invalid monster death function" }; optional( jo, was_loaded, "death_function", dies, death_reader ); if( dies.empty() ) { // TODO: really needed? Is an empty `dies` container not allowed? dies.push_back( mdeath::normal ); } assign( jo, "emit_fields", emit_fields ); if( jo.has_member( "special_when_hit" ) ) { JsonArray jsarr = jo.get_array( "special_when_hit" ); const auto iter = gen.defense_map.find( jsarr.get_string( 0 ) ); if( iter == gen.defense_map.end() ) { jsarr.throw_error( "Invalid monster defense function" ); } sp_defense = iter->second; def_chance = jsarr.get_int( 1 ); } else if( !was_loaded ) { sp_defense = &mdefense::none; def_chance = 0; } if( !was_loaded || jo.has_member( "special_attacks" ) ) { special_attacks.clear(); special_attacks_names.clear(); add_special_attacks( jo, "special_attacks", src ); } else { // Note: special_attacks left as is, new attacks are added to it! // Note: member name prefixes are compatible with those used by generic_typed_reader if( jo.has_object( "extend" ) ) { auto tmp = jo.get_object( "extend" ); add_special_attacks( tmp, "special_attacks", src ); } if( jo.has_object( "delete" ) ) { auto tmp = jo.get_object( "delete" ); remove_special_attacks( tmp, "special_attacks", src ); } } // Disable upgrading when JSON contains `"upgrades": false`, but fallback to the // normal behavior (including error checking) if "upgrades" is not boolean or not `false`. if( jo.has_bool( "upgrades" ) && !jo.get_bool( "upgrades" ) ) { upgrade_group = mongroup_id::NULL_ID(); upgrade_into = mtype_id::NULL_ID(); upgrades = false; } else if( jo.has_member( "upgrades" ) ) { JsonObject up = jo.get_object( "upgrades" ); optional( up, was_loaded, "half_life", half_life, -1 ); optional( up, was_loaded, "age_grow", age_grow, -1 ); optional( up, was_loaded, "into_group", upgrade_group, auto_flags_reader<mongroup_id> {}, mongroup_id::NULL_ID() ); optional( up, was_loaded, "into", upgrade_into, auto_flags_reader<mtype_id> {}, mtype_id::NULL_ID() ); upgrades = true; } //Reproduction if( jo.has_member( "reproduction" ) ) { JsonObject repro = jo.get_object( "reproduction" ); optional( repro, was_loaded, "baby_count", baby_count, -1 ); optional( repro, was_loaded, "baby_timer", baby_timer, -1 ); optional( repro, was_loaded, "baby_monster", baby_monster, auto_flags_reader<mtype_id> {}, mtype_id::NULL_ID() ); optional( repro, was_loaded, "baby_egg", baby_egg, auto_flags_reader<itype_id> {}, "null" ); if( jo.has_member( "baby_flags" ) ) { baby_flags.clear(); JsonArray baby_tags = jo.get_array( "baby_flags" ); while( baby_tags.has_more() ) { baby_flags.push_back( baby_tags.next_string() ); } } reproduces = true; } if( jo.has_member( "biosignature" ) ) { JsonObject biosig = jo.get_object( "biosignature" ); optional( biosig, was_loaded, "biosig_timer", biosig_timer, -1 ); optional( biosig, was_loaded, "biosig_item", biosig_item, auto_flags_reader<itype_id> {}, "null" ); biosignatures = true; } optional( jo, was_loaded, "burn_into", burn_into, auto_flags_reader<mtype_id> {}, mtype_id::NULL_ID() ); const typed_flag_reader<decltype( gen.flag_map )> flag_reader{ gen.flag_map, "invalid monster flag" }; optional( jo, was_loaded, "flags", flags, flag_reader ); // Can't calculate yet - we want all flags first optional( jo, was_loaded, "bash_skill", bash_skill, -1 ); const typed_flag_reader<decltype( gen.trigger_map )> trigger_reader{ gen.trigger_map, "invalid monster trigger" }; optional( jo, was_loaded, "anger_triggers", anger, trigger_reader ); optional( jo, was_loaded, "placate_triggers", placate, trigger_reader ); optional( jo, was_loaded, "fear_triggers", fear, trigger_reader ); if( jo.has_member( "path_settings" ) ) { auto jop = jo.get_object( "path_settings" ); // Here rather than in pathfinding.cpp because we want monster-specific defaults and was_loaded optional( jop, was_loaded, "max_dist", path_settings.max_dist, 0 ); optional( jop, was_loaded, "max_length", path_settings.max_length, -1 ); optional( jop, was_loaded, "bash_strength", path_settings.bash_strength, -1 ); optional( jop, was_loaded, "allow_open_doors", path_settings.allow_open_doors, false ); optional( jop, was_loaded, "avoid_traps", path_settings.avoid_traps, false ); optional( jop, was_loaded, "allow_climb_stairs", path_settings.allow_climb_stairs, true ); } }
void mission_type::load( JsonObject &jo, const std::string &src ) { const bool strict = src == "dda"; mandatory( jo, was_loaded, "name", name ); mandatory( jo, was_loaded, "difficulty", difficulty ); mandatory( jo, was_loaded, "value", value ); if( jo.has_member( "origins" ) ) { origins.clear(); for( auto &m : jo.get_tags( "origins" ) ) { origins.emplace_back( io::string_to_enum_look_up( io::origin_map, m ) ); } } if( std::any_of( origins.begin(), origins.end(), []( mission_origin origin ) { return origin == ORIGIN_ANY_NPC || origin == ORIGIN_OPENER_NPC || origin == ORIGIN_SECONDARY; } ) ) { auto djo = jo.get_object( "dialogue" ); // TODO: There should be a cleaner way to do it mandatory( djo, was_loaded, "describe", dialogue[ "describe" ] ); mandatory( djo, was_loaded, "offer", dialogue[ "offer" ] ); mandatory( djo, was_loaded, "accepted", dialogue[ "accepted" ] ); mandatory( djo, was_loaded, "rejected", dialogue[ "rejected" ] ); mandatory( djo, was_loaded, "advice", dialogue[ "advice" ] ); mandatory( djo, was_loaded, "inquire", dialogue[ "inquire" ] ); mandatory( djo, was_loaded, "success", dialogue[ "success" ] ); mandatory( djo, was_loaded, "success_lie", dialogue[ "success_lie" ] ); mandatory( djo, was_loaded, "failure", dialogue[ "failure" ] ); } optional( jo, was_loaded, "urgent", urgent ); optional( jo, was_loaded, "item", item_id ); optional( jo, was_loaded, "count", item_count, 1 ); goal = jo.get_enum_value<decltype( goal )>( "goal" ); assign_function( jo, "place", place, tripoint_function_map ); if( jo.has_string( "start" ) ) { assign_function( jo, "start", start, mission_function_map ); } else if( jo.has_member( "start" ) ) { JsonObject j_start = jo.get_object( "start" ); parse_start( j_start ); } assign_function( jo, "end", end, mission_function_map ); assign_function( jo, "fail", fail, mission_function_map ); assign( jo, "deadline_low", deadline_low, false, 1_days ); assign( jo, "deadline_high", deadline_high, false, 1_days ); if( jo.has_member( "followup" ) ) { follow_up = mission_type_id( jo.get_string( "followup" ) ); } if( jo.has_member( "monster_species" ) ) { monster_species = species_id( jo.get_string( "monster_species" ) ); } if( jo.has_member( "monster_type" ) ) { monster_type = mtype_id( jo.get_string( "monster_type" ) ); } if( jo.has_member( "monster_kill_goal" ) ) { monster_kill_goal = jo.get_int( "monster_kill_goal" ); } assign( jo, "destination", target_id, strict ); }
void MonsterGenerator::load_monster(JsonObject &jo) { // id std::string mid; if (jo.has_member("id")){ mid = jo.get_string("id"); if (mon_templates.count(mid) > 0) { delete mon_templates[mid]; } mtype *newmon = new mtype; newmon->id = mid; newmon->name = jo.get_string("name","").c_str(); if(jo.has_member("name_plural")) { newmon->name_plural = jo.get_string("name_plural"); } else { // default behaviour: Assume the regular plural form (appending an “s”) newmon->name_plural = jo.get_string("name") + "s"; } newmon->description = _(jo.get_string("description").c_str()); newmon->mat = jo.get_string("material"); newmon->species = jo.get_tags("species"); newmon->categories = jo.get_tags("categories"); newmon->sym = jo.get_string("symbol")[0]; // will fail here if there is no symbol newmon->color = color_from_string(jo.get_string("color")); newmon->size = get_from_string(jo.get_string("size", "MEDIUM"), size_map, MS_MEDIUM); newmon->phase = get_from_string(jo.get_string("phase", "SOLID"), phase_map, SOLID); newmon->difficulty = jo.get_int("diff", 0); newmon->agro = jo.get_int("aggression", 0); newmon->morale = jo.get_int("morale", 0); newmon->speed = jo.get_int("speed", 0); newmon->melee_skill = jo.get_int("melee_skill", 0); newmon->melee_dice = jo.get_int("melee_dice", 0); newmon->melee_sides = jo.get_int("melee_dice_sides", 0); newmon->melee_cut = jo.get_int("melee_cut", 0); newmon->sk_dodge = jo.get_int("dodge", 0); newmon->armor_bash = jo.get_int("armor_bash", 0); newmon->armor_cut = jo.get_int("armor_cut", 0); newmon->hp = jo.get_int("hp", 0); newmon->sp_freq = jo.get_int("special_freq", 0); newmon->def_chance = jo.get_int("special_when_hit_freq", 0); newmon->luminance = jo.get_float("luminance", 0); if (jo.has_string("death_drops")) { newmon->death_drops = jo.get_string("death_drops"); } else if (jo.has_object("death_drops")) { JsonObject death_frop_json = jo.get_object("death_drops"); // Make up a group name, should be unique (include the monster id), newmon->death_drops = newmon->id + "_death_drops_auto"; const std::string subtype = death_frop_json.get_string("subtype", "distribution"); // and load the entry as a standard item group using the made up name. item_controller->load_item_group(death_frop_json, newmon->death_drops, subtype); } else if (jo.has_member("death_drops")) { jo.throw_error("invalid type, must be string or object", "death_drops"); } newmon->dies = get_death_functions(jo, "death_function"); newmon->sp_attack = get_attack_function(jo, "special_attack"); newmon->sp_defense = get_defense_function(jo, "special_when_hit"); std::set<std::string> flags, anger_trig, placate_trig, fear_trig, cats; flags = jo.get_tags("flags"); anger_trig = jo.get_tags("anger_triggers"); placate_trig = jo.get_tags("placate_triggers"); fear_trig = jo.get_tags("fear_triggers"); newmon->flags = get_set_from_tags(flags, flag_map, MF_NULL); newmon->anger = get_set_from_tags(anger_trig, trigger_map, MTRIG_NULL); newmon->fear = get_set_from_tags(fear_trig, trigger_map, MTRIG_NULL); newmon->placate = get_set_from_tags(placate_trig, trigger_map, MTRIG_NULL); mon_templates[mid] = newmon; } }