////////////////// faction.h
////
void faction::deserialize(JsonIn &jsin)
{
JsonObject jo = jsin.get_object();
jo.read("id", id);
jo.read("name", name);
goal = faction_goal(jo.get_int("goal", goal));
values = jo.get_int("values", values);
job1 = faction_job(jo.get_int("job1", job1));
job2 = faction_job(jo.get_int("job2", job2));
jo.read("likes_u", likes_u);
jo.read("respects_u", respects_u);
jo.read("known_by_u", known_by_u);
jo.read("strength", strength);
jo.read("sneak", sneak);
jo.read("crime", crime);
jo.read("cult", cult);
jo.read("good", good);
jo.read("omx", omx);
jo.read("omy", omy);
jo.read("mapx", mapx);
jo.read("mapy", mapy);
jo.read("size", size);
jo.read("power", power);
if (jo.has_array("opinion_of")) {
opinion_of = jo.get_int_array("opinion_of");
}
}
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_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);
destroy_only = j.get_bool("destroy_only", 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;
}
}
void MonsterGenerator::load_special_attacks(mtype *m, JsonObject &jo, std::string member) {
m->special_attacks.clear(); // make sure we're running with everything cleared
if( !jo.has_array( member ) ) {
return;
}
JsonArray outer = jo.get_array(member);
while( outer.has_more() ) {
if( outer.test_array() ) {
JsonArray inner = outer.next_array();
const auto &aname = inner.get_string(0);
if ( attack_map.find(aname) != attack_map.end() ) {
auto new_entry = mtype_special_attack(
attack_map[aname], inner.get_int(1) );
m->special_attacks[aname] = new_entry;
m->special_attacks_names.push_back(aname);
} else {
inner.throw_error("Invalid special_attacks");
}
} else if( outer.test_object() ) {
set_attack_from_object(
outer.next_object(), m->special_attacks, m->special_attacks_names );
} else {
outer.throw_error( "array element is neither array nor object." );
}
}
}
void Item_factory::load_gun(JsonObject& jo)
{
it_gun* gun_template = new it_gun();
gun_template->ammo = jo.get_string("ammo");
gun_template->skill_used = Skill::skill(jo.get_string("skill"));
gun_template->dmg_bonus = jo.get_int("ranged_damage");
gun_template->range = jo.get_int("range");
gun_template->dispersion = jo.get_int("dispersion");
gun_template->recoil = jo.get_int("recoil");
gun_template->durability = jo.get_int("durability");
gun_template->burst = jo.get_int("burst");
gun_template->clip = jo.get_int("clip_size");
gun_template->reload_time = jo.get_int("reload");
gun_template->pierce = jo.get_int("pierce", 0);
gun_template->ammo_effects = jo.get_tags("ammo_effects");
if ( jo.has_array("valid_mod_locations") ) {
JsonArray jarr = jo.get_array("valid_mod_locations");
while (jarr.has_more()){
JsonArray curr = jarr.next_array();
gun_template->valid_mod_locations.insert(std::pair<std::string, int>(curr.get_string(0), curr.get_int(1)));
gun_template->occupied_mod_locations.insert(std::pair<std::string, int>(curr.get_string(0), 0));
}
}
itype *new_item_template = gun_template;
load_basic_info(jo, new_item_template);
}
void MonsterGroupManager::LoadMonsterGroup(JsonObject &jo)
{
MonsterGroup g;
g.name = mongroup_id( jo.get_string("name") );
g.defaultMonster = mtype_id( jo.get_string("default") );
if (jo.has_array("monsters")) {
JsonArray monarr = jo.get_array("monsters");
while (monarr.has_more()) {
JsonObject mon = monarr.next_object();
const mtype_id name = mtype_id( mon.get_string("monster") );
int freq = mon.get_int("freq");
int cost = mon.get_int("cost_multiplier");
int pack_min = 1;
int pack_max = 1;
if(mon.has_member("pack_size")) {
JsonArray packarr = mon.get_array("pack_size");
pack_min = packarr.next_int();
pack_max = packarr.next_int();
}
int starts = 0;
int ends = 0;
if(mon.has_member("starts")) {
if (ACTIVE_WORLD_OPTIONS["MONSTER_UPGRADE_FACTOR"] > 0) {
starts = mon.get_int("starts") * ACTIVE_WORLD_OPTIONS["MONSTER_UPGRADE_FACTOR"];
} else {
// Default value if the monster upgrade factor is set to 0.0 - off
starts = mon.get_int("starts");
}
}
if(mon.has_member("ends")) {
if (ACTIVE_WORLD_OPTIONS["MONSTER_UPGRADE_FACTOR"] > 0) {
ends = mon.get_int("ends") * ACTIVE_WORLD_OPTIONS["MONSTER_UPGRADE_FACTOR"];
} else {
// Default value if the monster upgrade factor is set to 0.0 - off
ends = mon.get_int("ends");
}
}
MonsterGroupEntry new_mon_group = MonsterGroupEntry(name, freq, cost, pack_min, pack_max, starts,
ends);
if(mon.has_member("conditions")) {
JsonArray conditions_arr = mon.get_array("conditions");
while(conditions_arr.has_more()) {
new_mon_group.conditions.push_back(conditions_arr.next_string());
}
}
g.monsters.push_back(new_mon_group);
}
}
g.replace_monster_group = jo.get_bool("replace_monster_group", false);
g.new_monster_group = mongroup_id( jo.get_string("new_monster_group_id", mongroup_id::NULL_ID.str() ) );
g.monster_group_time = jo.get_int("replacement_time", 0);
g.is_safe = jo.get_bool( "is_safe", false );
monsterGroupMap[g.name] = g;
}
static mut_attack load_mutation_attack( JsonObject &jo )
{
mut_attack ret;
jo.read( "attack_text_u", ret.attack_text_u );
jo.read( "attack_text_npc", ret.attack_text_npc );
jo.read( "required_mutations", ret.required_mutations );
jo.read( "blocker_mutations", ret.blocker_mutations );
jo.read( "hardcoded_effect", ret.hardcoded_effect );
if( jo.has_string( "body_part" ) ) {
ret.bp = get_body_part_token( jo.get_string( "body_part" ) );
}
jo.read( "chance", ret.chance );
if( jo.has_array( "base_damage" ) ) {
JsonArray jo_dam = jo.get_array( "base_damage" );
ret.base_damage = load_damage_instance( jo_dam );
} else if( jo.has_object( "base_damage" ) ) {
JsonObject jo_dam = jo.get_object( "base_damage" );
ret.base_damage = load_damage_instance( jo_dam );
}
if( jo.has_array( "strength_damage" ) ) {
JsonArray jo_dam = jo.get_array( "strength_damage" );
ret.strength_damage = load_damage_instance( jo_dam );
} else if( jo.has_object( "strength_damage" ) ) {
JsonObject jo_dam = jo.get_object( "strength_damage" );
ret.strength_damage = load_damage_instance( jo_dam );
}
if( ret.attack_text_u.empty() || ret.attack_text_npc.empty() ) {
jo.throw_error( "Attack message unset" );
}
if( !ret.hardcoded_effect && ret.base_damage.empty() && ret.strength_damage.empty() ) {
jo.throw_error( "Damage unset" );
} else if( ret.hardcoded_effect && ( !ret.base_damage.empty() || !ret.strength_damage.empty() ) ) {
jo.throw_error( "Damage and hardcoded effect are both set (must be one, not both)" );
}
if( ret.chance <= 0 ) {
jo.throw_error( "Chance of procing must be set and positive" );
}
return ret;
}
distribution load_distribution( JsonObject &jo )
{
if( jo.has_float( "constant" ) ) {
return distribution::constant( jo.get_float( "constant" ) );
}
if( jo.has_float( "one_in" ) ) {
return distribution::one_in( jo.get_float( "one_in" ) );
}
if( jo.has_array( "dice" ) ) {
JsonArray jarr = jo.get_array( "dice" );
return distribution::dice_roll( jarr.get_int( 0 ), jarr.get_int( 1 ) );
}
if( jo.has_array( "rng" ) ) {
JsonArray jarr = jo.get_array( "rng" );
return distribution::rng_roll( jarr.get_int( 0 ), jarr.get_int( 1 ) );
}
if( jo.has_array( "sum" ) ) {
JsonArray jarr = jo.get_array( "sum" );
JsonObject obj = jarr.next_object();
distribution ret = load_distribution( obj );
while( jarr.has_more() ) {
obj = jarr.next_object();
ret = ret + load_distribution( obj );
}
return ret;
}
if( jo.has_array( "mul" ) ) {
JsonArray jarr = jo.get_array( "mul" );
JsonObject obj = jarr.next_object();
distribution ret = load_distribution( obj );
while( jarr.has_more() ) {
obj = jarr.next_object();
ret = ret * load_distribution( obj );
}
return ret;
}
jo.throw_error( "Invalid distribution" );
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);
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, "chance", chance );
jsonstring(j, "sound", sound );
jsonstring(j, "sound_fail", sound_fail );
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 melee_actor::load_internal( JsonObject &obj, const std::string & )
{
// Optional:
if( obj.has_array( "damage_max_instance" ) ) {
JsonArray arr = obj.get_array( "damage_max_instance" );
damage_max_instance = load_damage_instance( arr );
} else if( obj.has_object( "damage_max_instance" ) ) {
damage_max_instance = load_damage_instance( obj );
}
min_mul = obj.get_float( "min_mul", 0.0f );
max_mul = obj.get_float( "max_mul", 1.0f );
move_cost = obj.get_int( "move_cost", 100 );
accuracy = obj.get_int( "accuracy", INT_MIN );
optional( obj, was_loaded, "miss_msg_u", miss_msg_u, translated_string_reader,
_( "The %s lunges at you, but you dodge!" ) );
optional( obj, was_loaded, "no_dmg_msg_u", no_dmg_msg_u, translated_string_reader,
_( "The %1$s bites your %2$s, but fails to penetrate armor!" ) );
optional( obj, was_loaded, "hit_dmg_u", hit_dmg_u, translated_string_reader,
_( "The %1$s bites your %2$s!" ) );
optional( obj, was_loaded, "miss_msg_npc", miss_msg_npc, translated_string_reader,
_( "The %s lunges at <npcname>, but they dodge!" ) );
optional( obj, was_loaded, "no_dmg_msg_npc", no_dmg_msg_npc, translated_string_reader,
_( "The %1$s bites <npcname>'s %2$s, but fails to penetrate armor!" ) );
optional( obj, was_loaded, "hit_dmg_npc", hit_dmg_npc, translated_string_reader,
_( "The %1$s bites <npcname>'s %2$s!" ) );
if( obj.has_array( "body_parts" ) ) {
JsonArray jarr = obj.get_array( "body_parts" );
while( jarr.has_more() ) {
JsonArray sub = jarr.next_array();
const body_part bp = get_body_part_token( sub.get_string( 0 ) );
const float prob = sub.get_float( 1 );
body_parts.add_or_replace( bp, prob );
}
}
if( obj.has_array( "effects" ) ) {
JsonArray jarr = obj.get_array( "effects" );
while( jarr.has_more() ) {
JsonObject eff = jarr.next_object();
effects.push_back( load_mon_effect_data( eff ) );
}
}
}
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 );
}
}
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" ) ) {
JsonArray jarr = jo.get_array( "traits" );
while( jarr.has_more() ) {
JsonArray jarr_in = jarr.next_array();
traits[ trait_id( jarr_in.get_string( 0 ) ) ] = jarr_in.get_int( 1 );
}
}
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 snippet_library::load_snippet( JsonObject &jsobj )
{
std::string category = jsobj.get_string( "category" );
if( jsobj.has_array( "text" ) ) {
JsonArray jarr = jsobj.get_array( "text" );
add_snippets_from_json( category, jarr );
} else {
add_snippet_from_json( category, jsobj );
}
}
void MonsterGenerator::load_special_defense(mtype *m, JsonObject &jo, std::string member) {
if (jo.has_array(member)) {
JsonArray jsarr = jo.get_array(member);
m->sp_defense = defense_map[jsarr.get_string(0)];
m->def_chance = jsarr.get_int(1);
}
if (m->sp_defense == NULL) {
m->sp_defense = defense_map["NONE"];
}
}
void json_item_substitution::load( JsonObject &jo )
{
if( !jo.has_array( "substitutions" ) ) {
jo.throw_error( "No `substitutions` array found." );
}
JsonArray outer_arr = jo.get_array( "substitutions" );
while( outer_arr.has_more() ) {
JsonObject subobj = outer_arr.next_object();
do_load( subobj );
}
}
void it_artifact_armor::deserialize(JsonObject &jo)
{
id = jo.get_string("id");
name = jo.get_string("name");
description = jo.get_string("description");
sym = jo.get_int("sym");
color = int_to_color(jo.get_int("color"));
price = jo.get_int("price");
// LEGACY: Since it seems artifacts get serialized out to disk, and they're
// dynamic, we need to allow for them to be read from disk for, oh, I guess
// quite some time. Loading and saving once will write things out as a JSON
// array.
if (jo.has_string("m1")) {
materials.push_back(jo.get_string("m1"));
}
if (jo.has_string("m2")) {
materials.push_back(jo.get_string("m2"));
}
// Assumption, perhaps dangerous, that we won't wind up with m1 and m2 and
// a materials array in our serialized objects at the same time.
if (jo.has_array("materials")) {
JsonArray jarr = jo.get_array("materials");
for (int i = 0; i < jarr.size(); ++i) {
materials.push_back(jarr.get_string(i));
}
}
if (materials.size() == 0) {
// I don't think we need this, but a lot of code seems to want at least
// one material and I'm not sure I found every single corner case.
materials.push_back("null");
}
volume = jo.get_int("volume");
weight = jo.get_int("weight");
melee_dam = jo.get_int("melee_dam");
melee_cut = jo.get_int("melee_cut");
m_to_hit = jo.get_int("m_to_hit");
item_tags = jo.get_tags("item_flags");
jo.read( "covers", covers);
encumber = jo.get_int("encumber");
coverage = jo.get_int("coverage");
thickness = jo.get_int("material_thickness");
env_resist = jo.get_int("env_resist");
warmth = jo.get_int("warmth");
storage = jo.get_int("storage");
power_armor = jo.get_bool("power_armor");
JsonArray ja = jo.get_array("effects_worn");
while (ja.has_more()) {
effects_worn.push_back((art_effect_passive)ja.next_int());
}
}
void Item_factory::set_qualities_from_json(JsonObject& jo, std::string member, itype* new_item_template)
{
if ( jo.has_array(member) ) {
JsonArray jarr = jo.get_array(member);
while (jarr.has_more()){
JsonArray curr = jarr.next_array();
new_item_template->qualities.insert(std::pair<std::string, int>(curr.get_string(0), curr.get_int(1)));
}
} else {
debugmsg("Qualities list for item %s not an array", new_item_template->id.c_str());
}
}
VehicleFacings::VehicleFacings(JsonObject &jo, const std::string &key)
{
if(jo.has_array(key)) {
JsonArray jpos = jo.get_array(key);
while (jpos.has_more()) {
values.push_back(jpos.next_int());
}
}
else {
values.push_back(jo.get_int(key));
}
}
bool map_bash_info::load(JsonObject &jsobj, std::string member, bool isfurniture) {
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);
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);
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( isfurniture ) {
furn_set = j.get_string("furn_set", "f_null");
} else {
ter_set = 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;
}
void MonsterGroupManager::LoadMonsterGroup(JsonObject &jo)
{
MonsterGroup g;
g.name = jo.get_string("name");
g.defaultMonster = jo.get_string("default");
if (jo.has_array("monsters")) {
JsonArray monarr = jo.get_array("monsters");
while (monarr.has_more()) {
JsonObject mon = monarr.next_object();
std::string name = mon.get_string("monster");
int freq = mon.get_int("freq");
int cost = mon.get_int("cost_multiplier");
int pack_min = 1;
int pack_max = 1;
if(mon.has_member("pack_size")) {
JsonArray packarr = mon.get_array("pack_size");
pack_min = packarr.next_int();
pack_max = packarr.next_int();
}
int starts = 0;
int ends = 0;
if(mon.has_member("starts")) {
starts = mon.get_int("starts") * ACTIVE_WORLD_OPTIONS["MONSTER_GROUP_DIFFICULTY"];
}
if(mon.has_member("ends")) {
ends = mon.get_int("ends") * ACTIVE_WORLD_OPTIONS["MONSTER_GROUP_DIFFICULTY"];
}
MonsterGroupEntry new_mon_group = MonsterGroupEntry(name, freq, cost, pack_min, pack_max, starts,
ends);
if(mon.has_member("conditions")) {
JsonArray conditions_arr = mon.get_array("conditions");
while(conditions_arr.has_more()) {
new_mon_group.conditions.push_back(conditions_arr.next_string());
}
}
g.monsters.push_back(new_mon_group);
}
}
g.replace_monster_group = jo.get_bool("replace_monster_group", false);
g.new_monster_group = jo.get_string("new_monster_group_id", "NULL");
g.monster_group_time = jo.get_int("replacement_time", 0);
monsterGroupMap[g.name] = g;
}
void game::load_monitem(JsonObject &jo) {
std::vector<std::string> tmp_keys;
std::vector<items_location_and_chance> tmp_items;
std::string mkey="";
if ( jo.has_string("id") ) {
tmp_keys.push_back( jo.get_string("id") );
} else if ( jo.has_array("id") ) {
jo.read("id", tmp_keys);
} else {
jo.throw_error("monitems: requires \"id\": \"monster_id\" or \"id\": [ \"multiple\", \"monster_ids\" ]");
}
if ( ! jo.has_array("item_groups") ) {
jo.throw_error("monitems: requires \"item_groups\": [ [ \"group_one\", (chance) ], ... ]");
}
JsonArray ja = jo.get_array("item_groups");
JsonArray ga;
while ( ja.has_more() ) {
ga = ja.next_array();
if ( ! ga.has_string(0) || ! ga.has_number(1) ) {
jo.throw_error("monitems: item_groups must contain arrays of [ \"string\", number ]");
}
tmp_items.push_back( items_location_and_chance( ga.get_string(0), ga.get_int(1) ) );
}
for( size_t i = 0; i < tmp_keys.size(); ++i ) {
std::map<std::string, std::vector <items_location_and_chance> >::iterator it = monitems.find( tmp_keys[i] );
if ( it == monitems.end() ) {
monitems[ tmp_keys[i] ] = tmp_items;
} else {
it->second.insert( it->second.end(), tmp_items.begin(), tmp_items.end() );
}
}
}
damage_instance load_damage_instance( JsonObject &jo )
{
damage_instance di;
if( jo.has_array( "values" ) ) {
JsonArray jarr = jo.get_array( "values" );
while( jarr.has_more() ) {
JsonObject curr = jarr.next_object();
di.damage_units.push_back( load_damage_unit( curr ) );
}
} else if( jo.has_string( "damage_type" ) ) {
di.damage_units.push_back( load_damage_unit( jo ) );
}
return di;
}
void MonsterGenerator::load_special_defense(mtype *m, JsonObject &jo, std::string member) {
if (jo.has_array(member)) {
JsonArray jsarr = jo.get_array(member);
if ( defense_map.find(jsarr.get_string(0)) != defense_map.end() ) {
m->sp_defense = defense_map[jsarr.get_string(0)];
m->def_chance = jsarr.get_int(1);
} else {
jsarr.throw_error("Invalid special_when_hit");
}
}
if (m->sp_defense == NULL) {
m->sp_defense = defense_map["NONE"];
}
}
void bite_actor::load( JsonObject &obj )
{
// Optional:
if( obj.has_array( "damage_max_instance" ) ) {
JsonArray arr = obj.get_array( "damage_max_instance" );
damage_max_instance = load_damage_instance( arr );
} else if( obj.has_object( "damage_max_instance" ) ) {
damage_max_instance = load_damage_instance( obj );
}
min_mul = obj.get_float( "min_mul", 0.0f );
max_mul = obj.get_float( "max_mul", 1.0f );
move_cost = obj.get_int( "move_cost", 100 );
accuracy = obj.get_int( "accuracy", INT_MIN );
no_infection_chance = obj.get_int( "no_infection_chance", 14 );
}
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 mtype::add_special_attacks( JsonObject &jo, const std::string &member ) {
if( !jo.has_array( member ) ) {
return;
}
JsonArray outer = jo.get_array(member);
while( outer.has_more() ) {
if( outer.test_array() ) {
add_special_attack( outer.next_array() );
} else if( outer.test_object() ) {
add_special_attack( outer.next_object() );
} else {
outer.throw_error( "array element is neither array nor object." );
}
}
}
void Item_factory::set_material_from_json(JsonObject& jo, std::string member, itype* new_item_template)
{
//If the value isn't found, just return a group of null materials
std::string material_list[2] = {"null", "null"};
if( jo.has_array(member) ) {
JsonArray jarr = jo.get_array(member);
if (jarr.size() > 2) {
debugmsg("Too many materials provided for item %s", new_item_template->id.c_str());
}
material_list[0] = jarr.get_string(0);
material_list[1] = jarr.get_string(1);
} else if ( jo.has_string(member) ) {
material_list[0] = jo.get_string(member);
}
new_item_template->m1 = material_list[0];
new_item_template->m2 = material_list[1];
}
void MonsterGenerator::load_special_attacks(mtype *m, JsonObject &jo, std::string member) {
m->sp_attack.clear(); // make sure we're running with
m->sp_freq.clear(); // everything cleared
if (jo.has_array(member)) {
JsonArray outer = jo.get_array(member);
while (outer.has_more()) {
JsonArray inner = outer.next_array();
m->sp_attack.push_back(attack_map[inner.get_string(0)]);
m->sp_freq.push_back(inner.get_int(1));
}
}
if (m->sp_attack.empty()) {
m->sp_attack.push_back(attack_map["NONE"]);
m->sp_freq.push_back(0);
}
}
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 MonsterGroupManager::LoadMonsterGroup(JsonObject &jo)
{
MonsterGroup g;
g.name = jo.get_string("name");
g.defaultMonster = jo.get_string("default");
if (jo.has_array("monsters")){
JsonArray monarr = jo.get_array("monsters");
while (monarr.has_more()) {
JsonObject mon = monarr.next_object();
std::string name = mon.get_string("monster");
int freq = mon.get_int("freq");
int cost = mon.get_int("cost_multiplier");
int pack_min = 1;
int pack_max = 1;
if(mon.has_member("pack_size")){
JsonArray packarr = mon.get_array("pack_size");
pack_min = packarr.next_int();
pack_max = packarr.next_int();
}
int starts = 0;
int ends = 0;
if(mon.has_member("starts")){
starts = mon.get_int("starts");
}
if(mon.has_member("ends")){
ends = mon.get_int("ends");
}
MonsterGroupEntry new_mon_group = MonsterGroupEntry(name,freq,cost,pack_min,pack_max,starts,ends);
if(mon.has_member("conditions")){
JsonArray conditions_arr = mon.get_array("conditions");
while(conditions_arr.has_more()){
new_mon_group.conditions.push_back(conditions_arr.next_string());
}
}
g.monsters.push_back(new_mon_group);
}
}
monsterGroupMap[g.name] = g;
}
void map_data_common_t::load( JsonObject &jo, const std::string &src )
{
if( jo.has_member( "examine_action" ) ) {
examine = iexamine_function_from_string( jo.get_string( "examine_action" ) );
} else {
examine = iexamine_function_from_string( "none" );
}
if( jo.has_array( "harvest_by_season" ) ) {
JsonArray jsarr = jo.get_array( "harvest_by_season" );
while( jsarr.has_more() ) {
JsonObject harvest_jo = jsarr.next_object();
auto season_strings = harvest_jo.get_tags( "seasons" );
std::set<season_type> seasons;
std::transform( season_strings.begin(), season_strings.end(), std::inserter( seasons,
seasons.begin() ),
[]( const std::string & data ) {
return io::string_to_enum<season_type>( data );
} );
harvest_id hl;
if( harvest_jo.has_array( "entries" ) ) {
// @todo: A better inline name - can't use id or name here because it's not set yet
size_t num = harvest_list::all().size() + 1;
hl = harvest_list::load( harvest_jo, src,
string_format( "harvest_inline_%d", static_cast<int>( num ) ) );
} else if( harvest_jo.has_string( "id" ) ) {
hl = harvest_id( harvest_jo.get_string( "id" ) );
} else {
jo.throw_error( "Each harvest entry must specify either \"entries\" or \"id\"",
"harvest_by_season" );
}
for( season_type s : seasons ) {
harvest_by_season[ s ] = hl;
}
}
}
optional( jo, false, "description", description, translated_string_reader );
}