mon_effect_data load_mon_effect_data( JsonObject &e )
{
return mon_effect_data( efftype_id( e.get_string( "id" ) ), e.get_int( "duration", 0 ),
e.get_bool( "affect_hit_bp", false ),
get_body_part_token( e.get_string( "bp", "NUM_BP" ) ),
e.get_bool( "permanent", false ),
e.get_int( "chance", 100 ) );
}
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;
}
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 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 );
}
bool game::dump_stats( const std::string &what, dump_mode mode,
const std::vector<std::string> &opts )
{
try {
loading_ui ui( false );
load_core_data( ui );
load_packs( _( "Loading content packs" ), { mod_id( "dda" ) }, ui );
DynamicDataLoader::get_instance().finalize_loaded_data( ui );
} catch( const std::exception &err ) {
std::cerr << "Error loading data from json: " << err.what() << std::endl;
return false;
}
std::vector<std::string> header;
std::vector<std::vector<std::string>> rows;
int scol = 0; // sorting column
std::map<std::string, standard_npc> test_npcs;
test_npcs[ "S1" ] = standard_npc( "S1", { "gloves_survivor", "mask_lsurvivor" }, 4, 8, 10, 8,
10 /* DEX 10, PER 10 */ );
test_npcs[ "S2" ] = standard_npc( "S2", { "gloves_fingerless", "sunglasses" }, 4, 8, 8, 8,
10 /* PER 10 */ );
test_npcs[ "S3" ] = standard_npc( "S3", { "gloves_plate", "helmet_plate" }, 4, 10, 8, 8,
8 /* STAT 10 */ );
test_npcs[ "S4" ] = standard_npc( "S4", {}, 0, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
test_npcs[ "S5" ] = standard_npc( "S5", {}, 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
test_npcs[ "S6" ] = standard_npc( "S6", { "gloves_hsurvivor", "mask_hsurvivor" }, 4, 8, 10, 8,
10 /* DEX 10, PER 10 */ );
std::map<std::string, item> test_items;
test_items[ "G1" ] = item( "glock_19" ).ammo_set( "9mm" );
test_items[ "G2" ] = item( "hk_mp5" ).ammo_set( "9mm" );
test_items[ "G3" ] = item( "ar15" ).ammo_set( "223" );
test_items[ "G4" ] = item( "remington_700" ).ammo_set( "270" );
test_items[ "G4" ].emplace_back( "rifle_scope" );
if( what == "AMMO" ) {
header = {
"Name", "Ammo", "Volume", "Weight", "Stack",
"Range", "Dispersion", "Recoil", "Damage", "Pierce"
};
auto dump = [&rows]( const item & obj ) {
// a common task is comparing ammo by type so ammo has multiple repeat the entry
for( const auto &e : obj.type->ammo->type ) {
std::vector<std::string> r;
r.push_back( obj.tname( 1, false ) );
r.push_back( e.str() );
r.push_back( to_string( obj.volume() / units::legacy_volume_factor ) );
r.push_back( to_string( to_gram( obj.weight() ) ) );
r.push_back( to_string( obj.type->stack_size ) );
r.push_back( to_string( obj.type->ammo->range ) );
r.push_back( to_string( obj.type->ammo->dispersion ) );
r.push_back( to_string( obj.type->ammo->recoil ) );
damage_instance damage = obj.type->ammo->damage;
r.push_back( to_string( damage.total_damage() ) );
r.push_back( to_string( damage.empty() ? 0 : ( *damage.begin() ).res_pen ) );
rows.push_back( r );
}
};
for( const itype *e : item_controller->all() ) {
if( e->ammo ) {
dump( item( e, calendar::turn, item::solitary_tag {} ) );
}
}
} else if( what == "ARMOR" ) {
header = {
"Name", "Encumber (fit)", "Warmth", "Weight", "Storage", "Coverage", "Bash", "Cut", "Acid", "Fire"
};
auto dump = [&rows]( const item & obj ) {
std::vector<std::string> r;
r.push_back( obj.tname( 1, false ) );
r.push_back( to_string( obj.get_encumber() ) );
r.push_back( to_string( obj.get_warmth() ) );
r.push_back( to_string( to_gram( obj.weight() ) ) );
r.push_back( to_string( obj.get_storage() / units::legacy_volume_factor ) );
r.push_back( to_string( obj.get_coverage() ) );
r.push_back( to_string( obj.bash_resist() ) );
r.push_back( to_string( obj.cut_resist() ) );
r.push_back( to_string( obj.acid_resist() ) );
r.push_back( to_string( obj.fire_resist() ) );
rows.push_back( r );
};
body_part bp = opts.empty() ? num_bp : get_body_part_token( opts.front() );
for( const itype *e : item_controller->all() ) {
if( e->armor ) {
item obj( e );
if( bp == num_bp || obj.covers( bp ) ) {
if( obj.has_flag( "VARSIZE" ) ) {
obj.item_tags.insert( "FIT" );
}
dump( obj );
}
}
}
} else if( what == "EDIBLE" ) {
header = {
"Name", "Volume", "Weight", "Stack", "Calories", "Quench", "Healthy"
};
for( const auto &v : vitamin::all() ) {
header.push_back( v.second.name() );
}
auto dump = [&rows]( const item & obj ) {
std::vector<std::string> r;
r.push_back( obj.tname( false ) );
r.push_back( to_string( obj.volume() / units::legacy_volume_factor ) );
r.push_back( to_string( to_gram( obj.weight() ) ) );
r.push_back( to_string( obj.type->stack_size ) );
r.push_back( to_string( obj.type->comestible->get_calories() ) );
r.push_back( to_string( obj.type->comestible->quench ) );
r.push_back( to_string( obj.type->comestible->healthy ) );
auto vits = g->u.vitamins_from( obj );
for( const auto &v : vitamin::all() ) {
r.push_back( to_string( vits[ v.first ] ) );
}
rows.push_back( r );
};
for( const itype *e : item_controller->all() ) {
item food( e, calendar::turn, item::solitary_tag {} );
if( food.is_food() && g->u.can_eat( food ).success() ) {
dump( food );
}
}
} else if( what == "GUN" ) {
header = {
"Name", "Ammo", "Volume", "Weight", "Capacity",
"Range", "Dispersion", "Effective recoil", "Damage", "Pierce",
"Aim time", "Effective range", "Snapshot range", "Max range"
};
std::set<std::string> locations;
for( const itype *e : item_controller->all() ) {
if( e->gun ) {
std::transform( e->gun->valid_mod_locations.begin(),
e->gun->valid_mod_locations.end(),
std::inserter( locations, locations.begin() ),
[]( const std::pair<gunmod_location, int> &q ) {
return q.first.name();
} );
}
}
for( const auto &e : locations ) {
header.push_back( e );
}
auto dump = [&rows, &locations]( const standard_npc & who, const item & obj ) {
std::vector<std::string> r;
r.push_back( obj.tname( 1, false ) );
r.push_back( obj.ammo_type() ? obj.ammo_type().str() : "" );
r.push_back( to_string( obj.volume() / units::legacy_volume_factor ) );
r.push_back( to_string( to_gram( obj.weight() ) ) );
r.push_back( to_string( obj.ammo_capacity() ) );
r.push_back( to_string( obj.gun_range() ) );
r.push_back( to_string( obj.gun_dispersion() ) );
r.push_back( to_string( obj.gun_recoil( who ) ) );
damage_instance damage = obj.gun_damage();
r.push_back( to_string( damage.total_damage() ) );
r.push_back( to_string( damage.empty() ? 0 : ( *damage.begin() ).res_pen ) );
r.push_back( to_string( who.gun_engagement_moves( obj ) ) );
for( const auto &e : locations ) {
const auto &vml = obj.type->gun->valid_mod_locations;
const auto iter = vml.find( e );
r.push_back( to_string( iter != vml.end() ? iter->second : 0 ) );
}
rows.push_back( r );
};
for( const itype *e : item_controller->all() ) {
if( e->gun ) {
item gun( e );
if( !gun.magazine_integral() ) {
gun.emplace_back( gun.magazine_default() );
}
gun.ammo_set( gun.ammo_type()->default_ammotype(), gun.ammo_capacity() );
dump( test_npcs[ "S1" ], gun );
if( gun.type->gun->barrel_length > 0 ) {
gun.emplace_back( "barrel_small" );
dump( test_npcs[ "S1" ], gun );
}
}
}
} else if( what == "RECIPE" ) {
// optionally filter recipes to include only those using specified skills
recipe_subset dict;
for( const auto &r : recipe_dict ) {
if( opts.empty() || std::any_of( opts.begin(), opts.end(), [&r]( const std::string & s ) {
if( r.second.skill_used == skill_id( s ) && r.second.difficulty > 0 ) {
return true;
}
auto iter = r.second.required_skills.find( skill_id( s ) );
return iter != r.second.required_skills.end() && iter->second > 0;
} ) ) {
dict.include( &r.second );
}
}
// only consider skills that are required by at least one recipe
std::vector<Skill> sk;
std::copy_if( Skill::skills.begin(), Skill::skills.end(),
std::back_inserter( sk ), [&dict]( const Skill & s ) {
return std::any_of( dict.begin(), dict.end(), [&s]( const recipe * r ) {
return r->skill_used == s.ident() ||
r->required_skills.find( s.ident() ) != r->required_skills.end();
} );
} );
header = { "Result" };
for( const auto &e : sk ) {
header.push_back( e.ident().str() );
}
for( const recipe *e : dict ) {
std::vector<std::string> r;
r.push_back( e->result_name() );
for( const auto &s : sk ) {
if( e->skill_used == s.ident() ) {
r.push_back( to_string( e->difficulty ) );
} else {
auto iter = e->required_skills.find( s.ident() );
r.push_back( to_string( iter != e->required_skills.end() ? iter->second : 0 ) );
}
}
rows.push_back( r );
}
} else if( what == "VEHICLE" ) {
header = {
"Name", "Weight (empty)", "Weight (fueled)",
"Max velocity (mph)", "Safe velocity (mph)", "Acceleration (mph/turn)",
"Mass coeff %", "Aerodynamics coeff %", "Friction coeff %",
"Traction coeff % (grass)"
};
auto dump = [&rows]( const vproto_id & obj ) {
auto veh_empty = vehicle( obj, 0, 0 );
auto veh_fueled = vehicle( obj, 100, 0 );
std::vector<std::string> r;
r.push_back( veh_empty.name );
r.push_back( to_string( to_kilogram( veh_empty.total_mass() ) ) );
r.push_back( to_string( to_kilogram( veh_fueled.total_mass() ) ) );
r.push_back( to_string( veh_fueled.max_velocity() / 100 ) );
r.push_back( to_string( veh_fueled.safe_velocity() / 100 ) );
r.push_back( to_string( veh_fueled.acceleration() / 100 ) );
r.push_back( to_string( ( int )( 100 * veh_fueled.k_mass() ) ) );
r.push_back( to_string( ( int )( 100 * veh_fueled.k_aerodynamics() ) ) );
r.push_back( to_string( ( int )( 100 * veh_fueled.k_friction() ) ) );
r.push_back( to_string( ( int )( 100 * veh_fueled.k_traction( veh_fueled.wheel_area(
false ) / 2.0f ) ) ) );
rows.push_back( r );
};
for( auto &e : vehicle_prototype::get_all() ) {
dump( e );
}
} else if( what == "VPART" ) {
header = {
"Name", "Location", "Weight", "Size"
};
auto dump = [&rows]( const vpart_info & obj ) {
std::vector<std::string> r;
r.push_back( obj.name() );
r.push_back( obj.location );
r.push_back( to_string( int( ceil( to_gram( item( obj.item ).weight() ) / 1000.0 ) ) ) );
r.push_back( to_string( obj.size / units::legacy_volume_factor ) );
rows.push_back( r );
};
for( const auto &e : vpart_info::all() ) {
dump( e.second );
}
} else {
std::cerr << "unknown argument: " << what << std::endl;
return false;
}
rows.erase( std::remove_if( rows.begin(), rows.end(), []( const std::vector<std::string> &e ) {
return e.empty();
} ), rows.end() );
if( scol >= 0 ) {
std::sort( rows.begin(), rows.end(), [&scol]( const std::vector<std::string> &lhs,
const std::vector<std::string> &rhs ) {
return lhs[ scol ] < rhs[ scol ];
} );
}
rows.erase( std::unique( rows.begin(), rows.end() ), rows.end() );
switch( mode ) {
case dump_mode::TSV:
rows.insert( rows.begin(), header );
for( const auto &r : rows ) {
std::copy( r.begin(), r.end() - 1, std::ostream_iterator<std::string>( std::cout, "\t" ) );
std::cout << r.back() << "\n";
}
break;
case dump_mode::HTML:
std::cout << "<table>";
std::cout << "<thead>";
std::cout << "<tr>";
for( const auto &col : header ) {
std::cout << "<th>" << col << "</th>";
}
std::cout << "</tr>";
std::cout << "</thead>";
std::cout << "<tdata>";
for( const auto &r : rows ) {
std::cout << "<tr>";
for( const auto &col : r ) {
std::cout << "<td>" << col << "</td>";
}
std::cout << "</tr>";
}
std::cout << "</tdata>";
std::cout << "</table>";
break;
}
return true;
}
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;
}
bool game::dump_stats( const std::string& what, dump_mode mode, const std::vector<std::string> &opts )
{
try {
load_core_data();
} catch( const std::exception &err ) {
std::cerr << "Error loading data from json: " << err.what() << std::endl;
return false;
}
DynamicDataLoader::get_instance().finalize_loaded_data();
std::vector<std::string> header;
std::vector<std::vector<std::string>> rows;
int scol = 0; // sorting column
std::map<std::string, standard_npc> test_npcs;
test_npcs[ "S1" ] = standard_npc( "S1", { "gloves_survivor", "mask_lsurvivor" }, 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
test_npcs[ "S2" ] = standard_npc( "S2", { "gloves_fingerless", "sunglasses" }, 4, 8, 8, 8, 10 /* PER 10 */ );
test_npcs[ "S3" ] = standard_npc( "S3", { "gloves_plate", "helmet_plate" }, 4, 10, 8, 8, 8 /* STAT 10 */ );
test_npcs[ "S4" ] = standard_npc( "S4", {}, 0, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
test_npcs[ "S5" ] = standard_npc( "S5", {}, 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
test_npcs[ "S6" ] = standard_npc( "S6", { "gloves_hsurvivor", "mask_hsurvivor" }, 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
std::map<std::string, item> test_items;
test_items[ "G1" ] = item( "glock_19" ).ammo_set( "9mm" );
test_items[ "G2" ] = item( "hk_mp5" ).ammo_set( "9mm" );
test_items[ "G3" ] = item( "ar15" ).ammo_set( "223" );
test_items[ "G4" ] = item( "remington_700" ).ammo_set( "270" );
test_items[ "G4" ].emplace_back( "rifle_scope" );
if( what == "AMMO" ) {
header = {
"Name", "Ammo", "Volume", "Weight", "Stack",
"Range", "Dispersion", "Recoil", "Damage", "Pierce"
};
auto dump = [&rows]( const item& obj ) {
// a common task is comparing ammo by type so ammo has multiple repeat the entry
for( const auto &e : obj.type->ammo->type ) {
std::vector<std::string> r;
r.push_back( obj.tname( 1, false ) );
r.push_back( e.str() );
r.push_back( to_string( obj.volume() / units::legacy_volume_factor ) );
r.push_back( to_string( obj.weight() ) );
r.push_back( to_string( obj.type->stack_size ) );
r.push_back( to_string( obj.type->ammo->range ) );
r.push_back( to_string( obj.type->ammo->dispersion ) );
r.push_back( to_string( obj.type->ammo->recoil ) );
r.push_back( to_string( obj.type->ammo->damage ) );
r.push_back( to_string( obj.type->ammo->pierce ) );
rows.push_back( r );
}
};
for( auto& e : item_controller->get_all_itypes() ) {
if( e.second.ammo ) {
dump( item( e.first, calendar::turn, item::solitary_tag {} ) );
}
}
} else if( what == "ARMOR" ) {
header = {
"Name", "Encumber (fit)", "Warmth", "Weight", "Storage", "Coverage", "Bash", "Cut", "Acid", "Fire"
};
auto dump = [&rows]( const item& obj ) {
std::vector<std::string> r;
r.push_back( obj.tname( 1, false ) );
r.push_back( to_string( obj.get_encumber() ) );
r.push_back( to_string( obj.get_warmth() ) );
r.push_back( to_string( obj.weight() ) );
r.push_back( to_string( obj.get_storage() / units::legacy_volume_factor ) );
r.push_back( to_string( obj.get_coverage() ) );
r.push_back( to_string( obj.bash_resist() ) );
r.push_back( to_string( obj.cut_resist() ) );
r.push_back( to_string( obj.acid_resist() ) );
r.push_back( to_string( obj.fire_resist() ) );
rows.push_back( r );
};
body_part bp = opts.empty() ? num_bp : get_body_part_token( opts.front() );
for( auto& e : item_controller->get_all_itypes() ) {
if( e.second.armor ) {
item obj( e.first );
if( bp == num_bp || obj.covers( bp ) ) {
if( obj.has_flag( "VARSIZE" ) ) {
obj.item_tags.insert( "FIT" );
}
dump( obj );
}
}
}
} else if( what == "EDIBLE" ) {
header = {
"Name", "Volume", "Weight", "Stack", "Calories", "Quench", "Healthy"
};
for( const auto& v : vitamin::all() ) {
header.push_back( v.second.name() );
}
auto dump = [&rows,&test_npcs]( const item& obj ) {
std::vector<std::string> r;
r.push_back( obj.tname( false ) );
r.push_back( to_string( obj.volume() / units::legacy_volume_factor ) );
r.push_back( to_string( obj.weight() ) );
r.push_back( to_string( obj.type->stack_size ) );
r.push_back( to_string( obj.type->comestible->get_calories() ) );
r.push_back( to_string( obj.type->comestible->quench ) );
r.push_back( to_string( obj.type->comestible->healthy ) );
auto vits = g->u.vitamins_from( obj );
for( const auto& v : vitamin::all() ) {
r.push_back( to_string( vits[ v.first ] ) );
}
rows.push_back( r );
};
for( auto& e : item_controller->get_all_itypes() ) {
if( e.second.comestible &&
( e.second.comestible->comesttype == "FOOD" ||
e.second.comestible->comesttype == "DRINK" ) ) {
item food( e.first, calendar::turn, item::solitary_tag {} );
if( g->u.can_eat( food, false, true ) == EDIBLE ) {
dump( food );
}
}
}
} else if( what == "GUN" ) {
header = {
"Name", "Ammo", "Volume", "Weight", "Capacity",
"Range", "Dispersion", "Effective recoil", "Damage", "Pierce",
"Aim time", "Effective range", "Snapshot range", "Max range"
};
std::set<std::string> locations;
for( const auto& e : item_controller->get_all_itypes() ) {
if( e.second.gun ) {
std::transform( e.second.gun->valid_mod_locations.begin(),
e.second.gun->valid_mod_locations.end(),
std::inserter( locations, locations.begin() ),
[]( const std::pair<std::string, int>& e ) { return e.first; } );
}
}
for( const auto &e : locations ) {
header.push_back( e );
}
auto dump = [&rows,&locations]( const standard_npc &who, const item& obj ) {
std::vector<std::string> r;
r.push_back( obj.tname( 1, false ) );
r.push_back( obj.ammo_type() ? obj.ammo_type().str() : "" );
r.push_back( to_string( obj.volume() / units::legacy_volume_factor ) );
r.push_back( to_string( obj.weight() ) );
r.push_back( to_string( obj.ammo_capacity() ) );
r.push_back( to_string( obj.gun_range() ) );
r.push_back( to_string( obj.gun_dispersion() ) );
r.push_back( to_string( obj.gun_recoil( who ) ) );
r.push_back( to_string( obj.gun_damage() ) );
r.push_back( to_string( obj.gun_pierce() ) );
r.push_back( to_string( who.gun_engagement_moves( obj ) ) );
r.push_back( string_format( "%.1f", who.gun_engagement_range( obj, player::engagement::effective ) ) );
r.push_back( string_format( "%.1f", who.gun_engagement_range( obj, player::engagement::snapshot ) ) );
r.push_back( string_format( "%.1f", who.gun_engagement_range( obj, player::engagement::maximum ) ) );
for( const auto &e : locations ) {
r.push_back( to_string( obj.type->gun->valid_mod_locations[ e ] ) );
}
rows.push_back( r );
};
for( const auto& e : item_controller->get_all_itypes() ) {
if( e.second.gun ) {
item gun( e.first );
if( !gun.magazine_integral() ) {
gun.emplace_back( gun.magazine_default() );
}
gun.ammo_set( default_ammo( gun.ammo_type() ), gun.ammo_capacity() );
dump( test_npcs[ "S1" ], gun );
if( gun.type->gun->barrel_length > 0 ) {
gun.emplace_back( "barrel_small" );
dump( test_npcs[ "S1" ], gun );
}
}
}
} else if( what == "VEHICLE" ) {
header = {
"Name", "Weight (empty)", "Weight (fueled)",
"Max velocity (mph)", "Safe velocity (mph)", "Acceleration (mph/turn)",
"Mass coeff %", "Aerodynamics coeff %", "Friction coeff %",
"Traction coeff % (grass)"
};
auto dump = [&rows]( const vproto_id& obj ) {
auto veh_empty = vehicle( obj, 0, 0 );
auto veh_fueled = vehicle( obj, 100, 0 );
std::vector<std::string> r;
r.push_back( veh_empty.name );
r.push_back( to_string( veh_empty.total_mass() ) );
r.push_back( to_string( veh_fueled.total_mass() ) );
r.push_back( to_string( veh_fueled.max_velocity() / 100 ) );
r.push_back( to_string( veh_fueled.safe_velocity() / 100 ) );
r.push_back( to_string( veh_fueled.acceleration() / 100 ) );
r.push_back( to_string( (int)( 100 * veh_fueled.k_mass() ) ) );
r.push_back( to_string( (int)( 100 * veh_fueled.k_aerodynamics() ) ) );
r.push_back( to_string( (int)( 100 * veh_fueled.k_friction() ) ) );
r.push_back( to_string( (int)( 100 * veh_fueled.k_traction( veh_fueled.wheel_area( false ) / 2.0f ) ) ) );
rows.push_back( r );
};
for( auto& e : vehicle_prototype::get_all() ) {
dump( e );
}
} else if( what == "VPART" ) {
header = {
"Name", "Location", "Weight", "Size"
};
auto dump = [&rows]( const vpart_info &obj ) {
std::vector<std::string> r;
r.push_back( obj.name() );
r.push_back( obj.location );
r.push_back( to_string( int( ceil( item( obj.item ).weight() / 1000.0 ) ) ) );
r.push_back( to_string( obj.size / units::legacy_volume_factor ) );
rows.push_back( r );
};
for( const auto &e : vpart_info::all() ) {
dump( e.second );
}
} else if( what == "AIMING" ) {
scol = -1; // unsorted output so graph columns have predictable ordering
const int cycles = 1400;
header = { "Name" };
for( int i = 0; i <= cycles; ++i ) {
header.push_back( to_string( i ) );
}
auto dump = [&rows]( const standard_npc &who, const item &gun) {
std::vector<std::string> r( 1, string_format( "%s %s", who.get_name().c_str(), gun.tname().c_str() ) );
double penalty = MIN_RECOIL;
for( int i = 0; i <= cycles; ++i ) {
penalty -= who.aim_per_move( gun, penalty );
r.push_back( string_format( "%.2f", who.gun_current_range( gun, penalty ) ) );
}
rows.push_back( r );
};
if( opts.empty() ) {
dump( test_npcs[ "S1" ], test_items[ "G1" ] );
dump( test_npcs[ "S1" ], test_items[ "G2" ] );
dump( test_npcs[ "S1" ], test_items[ "G3" ] );
dump( test_npcs[ "S1" ], test_items[ "G4" ] );
} else {
for( const auto &str : opts ) {
auto idx = str.find( ':' );
if( idx == std::string::npos ) {
std::cerr << "cannot parse test case: " << str << std::endl;
return false;
}
auto test = std::make_pair( test_npcs.find( str.substr( 0, idx ) ),
test_items.find( str.substr( idx + 1 ) ) );
if( test.first == test_npcs.end() || test.second == test_items.end() ) {
std::cerr << "invalid test case: " << str << std::endl;
return false;
}
dump( test.first->second, test.second->second );
}
}
} else if( what == "EXPLOSIVE" ) {
header = {
// @todo Should display more useful data: shrapnel damage, safe range
"Name", "Power", "Power at 5 tiles", "Power halves at", "Shrapnel count", "Shrapnel mass"
};
auto dump = [&rows]( const std::string &name, const explosion_data &ex ) {
std::vector<std::string> r;
r.push_back( name );
r.push_back( to_string( ex.power ) );
r.push_back( string_format( "%.1f", ex.power_at_range( 5.0f ) ) );
r.push_back( string_format( "%.1f", ex.expected_range( 0.5f ) ) );
r.push_back( to_string( ex.shrapnel.count ) );
r.push_back( to_string( ex.shrapnel.mass ) );
rows.push_back( r );
};
for( const auto& e : item_controller->get_all_itypes() ) {
const auto &itt = e.second;
const auto use = itt.get_use( "explosion" );
if( use != nullptr && use->get_actor_ptr() != nullptr ) {
const auto actor = dynamic_cast<const explosion_iuse *>( use->get_actor_ptr() );
if( actor != nullptr ) {
dump( itt.nname( 1 ), actor->explosion );
}
}
auto c_ex = dynamic_cast<const explosion_iuse *>( itt.countdown_action.get_actor_ptr() );
if( c_ex != nullptr ) {
dump( itt.nname( 1 ), c_ex->explosion );
}
}
} else {
std::cerr << "unknown argument: " << what << std::endl;
return false;
}
rows.erase( std::remove_if( rows.begin(), rows.end(), []( const std::vector<std::string>& e ) {
return e.empty();
} ), rows.end() );
if( scol >= 0 ) {
std::sort( rows.begin(), rows.end(), [&scol]( const std::vector<std::string>& lhs, const std::vector<std::string>& rhs ) {
return lhs[ scol ] < rhs[ scol ];
} );
}
rows.erase( std::unique( rows.begin(), rows.end() ), rows.end() );
switch( mode ) {
case dump_mode::TSV:
rows.insert( rows.begin(), header );
for( const auto& r : rows ) {
std::copy( r.begin(), r.end() - 1, std::ostream_iterator<std::string>( std::cout, "\t" ) );
std::cout << r.back() << "\n";
}
break;
case dump_mode::HTML:
std::cout << "<table>";
std::cout << "<thead>";
std::cout << "<tr>";
for( const auto& col : header ) {
std::cout << "<th>" << col << "</th>";
}
std::cout << "</tr>";
std::cout << "</thead>";
std::cout << "<tdata>";
for( const auto& r : rows ) {
std::cout << "<tr>";
for( const auto& col : r ) {
std::cout << "<td>" << col << "</td>";
}
std::cout << "</tr>";
}
std::cout << "</tdata>";
std::cout << "</table>";
break;
}
return true;
}
void mutation_branch::load( JsonObject &jsobj )
{
const std::string id = jsobj.get_string( "id" );
mutation_branch &new_mut = mutation_data[id];
JsonArray jsarr;
new_mut.name = _(jsobj.get_string("name").c_str());
new_mut.description = _(jsobj.get_string("description").c_str());
new_mut.points = jsobj.get_int("points");
new_mut.visibility = jsobj.get_int("visibility", 0);
new_mut.ugliness = jsobj.get_int("ugliness", 0);
new_mut.startingtrait = jsobj.get_bool("starting_trait", false);
new_mut.mixed_effect = jsobj.get_bool("mixed_effect", false);
new_mut.activated = jsobj.get_bool("active", false);
new_mut.starts_active = jsobj.get_bool("starts_active", false);
new_mut.destroys_gear = jsobj.get_bool("destroys_gear", false);
new_mut.allow_soft_gear = jsobj.get_bool("allow_soft_gear", false);
new_mut.cost = jsobj.get_int("cost", 0);
new_mut.cooldown = jsobj.get_int("time",0);
new_mut.hunger = jsobj.get_bool("hunger",false);
new_mut.thirst = jsobj.get_bool("thirst",false);
new_mut.fatigue = jsobj.get_bool("fatigue",false);
new_mut.valid = jsobj.get_bool("valid", true);
new_mut.purifiable = jsobj.get_bool("purifiable", true);
for( auto & s : jsobj.get_string_array( "initial_ma_styles" ) ) {
new_mut.initial_ma_styles.push_back( matype_id( s ) );
}
JsonArray bodytemp_array = jsobj.get_array( "bodytemp_modifiers" );
if( bodytemp_array.has_more() ) {
new_mut.bodytemp_min = bodytemp_array.get_int( 0 );
new_mut.bodytemp_max = bodytemp_array.get_int( 1 );
}
new_mut.bodytemp_sleep = jsobj.get_int( "bodytemp_sleep", 0 );
new_mut.threshold = jsobj.get_bool("threshold", false);
new_mut.profession = jsobj.get_bool("profession", false);
auto vr = jsobj.get_array( "vitamin_rates" );
while( vr.has_more() ) {
auto pair = vr.next_array();
new_mut.vitamin_rates[ vitamin_id( pair.get_string( 0 ) ) ] = pair.get_int( 1 );
}
load_mutation_mods(jsobj, "passive_mods", new_mut.mods);
/* Not currently supported due to inability to save active mutation state
load_mutation_mods(jsobj, "active_mods", new_mut.mods); */
new_mut.prereqs = jsobj.get_string_array( "prereqs" );
// Helps to be able to have a trait require more than one other trait
// (Individual prereq-lists are "OR", not "AND".)
// Traits shoud NOT appear in both lists for a given mutation, unless
// you want that trait to satisfy both requirements.
// These are additional to the first list.
new_mut.prereqs2 = jsobj.get_string_array( "prereqs2" );
// Dedicated-purpose prereq slot for Threshold mutations
// Stuff like Huge might fit in more than one mutcat post-threshold, so yeah
new_mut.threshreq = jsobj.get_string_array( "threshreq" );
new_mut.cancels = jsobj.get_string_array( "cancels" );
new_mut.replacements = jsobj.get_string_array( "changes_to" );
new_mut.additions = jsobj.get_string_array( "leads_to" );
new_mut.flags = jsobj.get_tags( "flags" );
jsarr = jsobj.get_array("category");
while (jsarr.has_more()) {
std::string s = jsarr.next_string();
new_mut.category.push_back(s);
mutations_category[s].push_back(id);
}
jsarr = jsobj.get_array("wet_protection");
while (jsarr.has_more()) {
JsonObject jo = jsarr.next_object();
std::string part_id = jo.get_string("part");
int ignored = jo.get_int("ignored", 0);
int neutral = jo.get_int("neutral", 0);
int good = jo.get_int("good", 0);
tripoint protect = tripoint(ignored, neutral, good);
new_mut.protection[get_body_part_token( part_id )] = protect;
}
jsarr = jsobj.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();
new_mut.encumbrance_always[get_body_part_token( part_id )] = enc;
}
jsarr = jsobj.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();
new_mut.encumbrance_covered[get_body_part_token( part_id )] = enc;
}
jsarr = jsobj.get_array("restricts_gear");
while( jsarr.has_more() ) {
new_mut.restricts_gear.insert( get_body_part_token( jsarr.next_string() ) );
}
jsarr = jsobj.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 muts protect whole body
for( size_t i = 0; i < num_bp; i++ ) {
bps.insert( static_cast<body_part>( i ) );
}
} else {
bps.insert( get_body_part_token( part_string ) );
}
}
resistances res = load_resistances_instance( jo );
for( body_part bp : bps ) {
new_mut.armor[ bp ] = res;
}
}
}
mon_effect_data get_next( JsonIn &jin ) const {
JsonObject e = jin.get_object();
return mon_effect_data( 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 ) );
}
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 mutation_branch::load( JsonObject &jsobj )
{
const std::string id = jsobj.get_string( "id" );
mutation_branch &new_mut = mutation_data[id];
JsonArray jsarr;
new_mut.name = _(jsobj.get_string("name").c_str());
new_mut.description = _(jsobj.get_string("description").c_str());
new_mut.points = jsobj.get_int("points");
new_mut.visibility = jsobj.get_int("visibility", 0);
new_mut.ugliness = jsobj.get_int("ugliness", 0);
new_mut.startingtrait = jsobj.get_bool("starting_trait", false);
new_mut.mixed_effect = jsobj.get_bool("mixed_effect", false);
new_mut.activated = jsobj.get_bool("active", false);
new_mut.cost = jsobj.get_int("cost", 0);
new_mut.cooldown = jsobj.get_int("time",0);
new_mut.hunger = jsobj.get_bool("hunger",false);
new_mut.thirst = jsobj.get_bool("thirst",false);
new_mut.fatigue = jsobj.get_bool("fatigue",false);
new_mut.valid = jsobj.get_bool("valid", true);
new_mut.purifiable = jsobj.get_bool("purifiable", true);
for( auto & s : jsobj.get_string_array( "initial_ma_styles" ) ) {
new_mut.initial_ma_styles.push_back( matype_id( s ) );
}
JsonArray bodytemp_array = jsobj.get_array( "bodytemp_modifiers" );
if( bodytemp_array.has_more() ) {
new_mut.bodytemp_min = bodytemp_array.get_int( 0 );
new_mut.bodytemp_max = bodytemp_array.get_int( 1 );
}
new_mut.bodytemp_sleep = jsobj.get_int( "bodytemp_sleep", 0 );
new_mut.threshold = jsobj.get_bool("threshold", false);
new_mut.profession = jsobj.get_bool("profession", false);
load_mutation_mods(jsobj, "passive_mods", new_mut.mods);
/* Not currently supported due to inability to save active mutation state
load_mutation_mods(jsobj, "active_mods", new_mut.mods); */
new_mut.prereqs = jsobj.get_string_array( "prereqs" );
// Helps to be able to have a trait require more than one other trait
// (Individual prereq-lists are "OR", not "AND".)
// Traits shoud NOT appear in both lists for a given mutation, unless
// you want that trait to satisfy both requirements.
// These are additional to the first list.
new_mut.prereqs2 = jsobj.get_string_array( "prereqs2" );
// Dedicated-purpose prereq slot for Threshold mutations
// Stuff like Huge might fit in more than one mutcat post-threshold, so yeah
new_mut.threshreq = jsobj.get_string_array( "threshreq" );
new_mut.cancels = jsobj.get_string_array( "cancels" );
new_mut.replacements = jsobj.get_string_array( "changes_to" );
new_mut.additions = jsobj.get_string_array( "leads_to" );
jsarr = jsobj.get_array("category");
while (jsarr.has_more()) {
std::string s = jsarr.next_string();
new_mut.category.push_back(s);
mutations_category[s].push_back(id);
}
jsarr = jsobj.get_array("wet_protection");
while (jsarr.has_more()) {
JsonObject jo = jsarr.next_object();
std::string part_id = jo.get_string("part");
int ignored = jo.get_int("ignored", 0);
int neutral = jo.get_int("neutral", 0);
int good = jo.get_int("good", 0);
tripoint protect = tripoint(ignored, neutral, good);
new_mut.protection[get_body_part_token( part_id )] = protect;
}
}
