void load_furniture(JsonObject &jsobj)
{
if ( furnlist.empty() ) {
furn_t new_null = null_furniture_t();
furnmap[new_null.id] = new_null;
furnlist.push_back(new_null);
}
furn_t new_furniture;
new_furniture.id = jsobj.get_string("id");
if ( new_furniture.id == "f_null" ) {
return;
}
new_furniture.name = _(jsobj.get_string("name").c_str());
new_furniture.sym = jsobj.get_string("symbol").c_str()[0];
bool has_color = jsobj.has_member("color");
bool has_bgcolor = jsobj.has_member("bgcolor");
if(has_color && has_bgcolor) {
debugmsg("Found both color and bgcolor for %s, use only one of these.", new_furniture.name.c_str());
new_furniture.color = c_white;
} else if(has_color) {
new_furniture.color = color_from_string(jsobj.get_string("color"));
} else if(has_bgcolor) {
new_furniture.color = bgcolor_from_string(jsobj.get_string("bgcolor"));
} else {
debugmsg("Furniture %s needs at least one of: color, bgcolor.", new_furniture.name.c_str());
}
new_furniture.movecost = jsobj.get_int("move_cost_mod");
new_furniture.move_str_req = jsobj.get_int("required_str");
new_furniture.transparent = false;
new_furniture.bitflags = 0;
JsonArray flags = jsobj.get_array("flags");
while(flags.has_more()) {
new_furniture.set_flag(flags.next_string());
}
if(jsobj.has_member("examine_action")) {
std::string function_name = jsobj.get_string("examine_action");
new_furniture.examine = iexamine_function_from_string(function_name);
} else {
//If not specified, default to no action
new_furniture.examine = iexamine_function_from_string("none");
}
new_furniture.open = "";
if ( jsobj.has_member("open") ) {
new_furniture.open = jsobj.get_string("open");
}
new_furniture.close = "";
if ( jsobj.has_member("close") ) {
new_furniture.close = jsobj.get_string("close");
}
new_furniture.bash.load(jsobj, "bash", true);
new_furniture.loadid = furnlist.size();
furnmap[new_furniture.id] = new_furniture;
furnlist.push_back(new_furniture);
}
void map_data_common_t::load_symbol( JsonObject &jo )
{
if( 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" );
}
load_season_array( jo, "symbol", symbol_, [&jo]( const std::string &str ) {
if( str == "LINE_XOXO" ) {
return LINE_XOXO;
} else if( str == "LINE_OXOX" ) {
return LINE_OXOX;
} else if( str.length() != 1 ) {
jo.throw_error( "Symbol string must be exactly 1 character long.", "symbol" );
}
return (int) str[0];
} );
const bool has_color = jo.has_member( "color" );
const bool has_bgcolor = jo.has_member( "bgcolor" );
if( has_color && has_bgcolor ) {
jo.throw_error( "Found both color and bgcolor, only one of these is allowed." );
} else if( has_color ) {
load_season_array( jo, "color", color_, color_from_string );
} else if( has_bgcolor ) {
load_season_array( jo, "bgcolor", color_, bgcolor_from_string );
} else {
jo.throw_error( "Missing member: one of: \"color\", \"bgcolor\" must exist." );
}
}
void zone_data::deserialize( JsonIn &jsin )
{
JsonObject data = jsin.get_object();
data.read( "name", name );
data.read( "type", type );
data.read( "invert", invert );
data.read( "enabled", enabled );
//Legacy support
if( data.has_member( "is_vehicle" ) ) {
data.read( "is_vehicle", is_vehicle );
} else {
is_vehicle = false;
}
//Legacy support
if( data.has_member( "start_x" ) ) {
tripoint s;
tripoint e;
data.read( "start_x", s.x );
data.read( "start_y", s.y );
data.read( "start_z", s.z );
data.read( "end_x", e.x );
data.read( "end_y", e.y );
data.read( "end_z", e.z );
start = s;
end = e;
} else {
data.read( "start", start );
data.read( "end", end );
}
auto new_options = zone_options::create( type );
new_options->deserialize( data );
options = new_options;
}
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;
}
void profession::load( JsonObject &jo, const std::string & )
{
//If the "name" is an object then we have to deal with gender-specific titles,
if( jo.has_object( "name" ) ) {
JsonObject name_obj = jo.get_object( "name" );
_name_male = pgettext( "profession_male", name_obj.get_string( "male" ).c_str() );
_name_female = pgettext( "profession_female", name_obj.get_string( "female" ).c_str() );
} else if( jo.has_string( "name" ) ) {
// Same profession names for male and female in English.
// Still need to different names in other languages.
const std::string name = jo.get_string( "name" );
_name_female = pgettext( "profession_female", name.c_str() );
_name_male = pgettext( "profession_male", name.c_str() );
} else if( !was_loaded ) {
jo.throw_error( "missing mandatory member \"name\"" );
}
if( !was_loaded || jo.has_member( "description" ) ) {
const std::string desc = jo.get_string( "description" );
// These also may differ depending on the language settings!
_description_male = pgettext( "prof_desc_male", desc.c_str() );
_description_female = pgettext( "prof_desc_female", desc.c_str() );
}
mandatory( jo, was_loaded, "points", _point_cost );
if( !was_loaded || jo.has_member( "items" ) ) {
JsonObject items_obj = jo.get_object( "items" );
if( items_obj.has_array( "both" ) ) {
optional( items_obj, was_loaded, "both", legacy_starting_items, item_reader {} );
}
if( items_obj.has_object( "both" ) ) {
_starting_items = item_group::load_item_group( *items_obj.get_raw( "both" ), "collection" );
}
if( items_obj.has_array( "male" ) ) {
optional( items_obj, was_loaded, "male", legacy_starting_items_male, item_reader {} );
}
if( items_obj.has_object( "male" ) ) {
_starting_items_male = item_group::load_item_group( *items_obj.get_raw( "male" ), "collection" );
}
if( items_obj.has_array( "female" ) ) {
optional( items_obj, was_loaded, "female", legacy_starting_items_female, item_reader {} );
}
if( items_obj.has_object( "female" ) ) {
_starting_items_female = item_group::load_item_group( *items_obj.get_raw( "female" ),
"collection" );
}
}
optional( jo, was_loaded, "no_bonus", no_bonus );
optional( jo, was_loaded, "skills", _starting_skills, skilllevel_reader {} );
optional( jo, was_loaded, "addictions", _starting_addictions, addiction_reader {} );
// TODO: use string_id<bionic_type> or so
optional( jo, was_loaded, "CBMs", _starting_CBMs, auto_flags_reader<bionic_id> {} );
// TODO: use string_id<mutation_branch> or so
optional( jo, was_loaded, "traits", _starting_traits, auto_flags_reader<trait_id> {} );
optional( jo, was_loaded, "flags", flags, auto_flags_reader<> {} );
}
void mutation_branch::load_trait_group( JsonObject &jsobj, const trait_group::Trait_group_tag &gid,
const std::string &subtype )
{
if( subtype != "distribution" && subtype != "collection" && subtype != "old" ) {
jsobj.throw_error( "unknown trait group type", "subtype" );
}
Trait_group &tg = make_group_or_throw( gid, ( subtype == "collection" || subtype == "old" ) );
// TODO: (sm) Looks like this makes the new code backwards-compatible with the old format. Great if so!
if( subtype == "old" ) {
JsonArray traits = jsobj.get_array( "traits" );
while( traits.has_more() ) {
JsonArray pair = traits.next_array();
tg.add_trait_entry( trait_id( pair.get_string( 0 ) ), pair.get_int( 1 ) );
}
return;
}
// TODO: (sm) Taken from item_factory.cpp almost verbatim. Ensure that these work!
if( jsobj.has_member( "entries" ) ) {
JsonArray traits = jsobj.get_array( "entries" );
while( traits.has_more() ) {
JsonObject subobj = traits.next_object();
add_entry( tg, subobj );
}
}
if( jsobj.has_member( "traits" ) ) {
JsonArray traits = jsobj.get_array( "traits" );
while( traits.has_more() ) {
if( traits.test_string() ) {
tg.add_trait_entry( trait_id( traits.next_string() ), 100 );
} else if( traits.test_array() ) {
JsonArray subtrait = traits.next_array();
tg.add_trait_entry( trait_id( subtrait.get_string( 0 ) ), subtrait.get_int( 1 ) );
} else {
JsonObject subobj = traits.next_object();
add_entry( tg, subobj );
}
}
}
if( jsobj.has_member( "groups" ) ) {
JsonArray traits = jsobj.get_array( "groups" );
while( traits.has_more() ) {
if( traits.test_string() ) {
tg.add_group_entry( trait_group::Trait_group_tag( traits.next_string() ), 100 );
} else if( traits.test_array() ) {
JsonArray subtrait = traits.next_array();
tg.add_group_entry( trait_group::Trait_group_tag( traits.get_string( 0 ) ), subtrait.get_int( 1 ) );
} else {
JsonObject subobj = traits.next_object();
add_entry( tg, subobj );
}
}
}
}
void ter_t::load( JsonObject &jo )
{
mandatory( jo, was_loaded, "name", name, translated_string_reader );
mandatory( jo, was_loaded, "move_cost", movecost );
optional( jo, was_loaded, "max_volume", max_volume, MAX_VOLUME_IN_SQUARE );
optional( jo, was_loaded, "trap", trap_id_str );
load_symbol( jo );
trap = tr_null;
transparent = false;
connect_group = TERCONN_NONE;
for( auto &flag : jo.get_string_array( "flags" ) ) {
set_flag( flag );
}
// connect_group is initialised to none, then terrain flags are set, then finally
// connections from JSON are set. This is so that wall flags can set wall connections
// but can be overridden by explicit connections in JSON.
if( jo.has_member( "connects_to" ) ) {
set_connects( jo.get_string( "connects_to" ) );
}
if( jo.has_member( "examine_action" ) ) {
examine = iexamine_function_from_string( jo.get_string( "examine_action" ) );
} else {
examine = iexamine_function_from_string( "none" );
}
optional( jo, was_loaded, "harvestable", harvestable );
optional( jo, was_loaded, "open", open, NULL_ID );
optional( jo, was_loaded, "close", close, NULL_ID );
optional( jo, was_loaded, "transforms_into", transforms_into, NULL_ID );
optional( jo, was_loaded, "roof", roof, NULL_ID );
if( jo.has_member("harvest_season") ) {
const std::string season = jo.get_string( "harvest_season" );
if( season == "SPRING" ) {
harvest_season = season_type::SPRING;
} else if( season == "SUMMER" ) {
harvest_season = season_type::SUMMER;
} else if( season == "AUTUMN" ) {
harvest_season = season_type::AUTUMN;
} else if( season == "WINTER" ) {
harvest_season = season_type::WINTER;
} else {
harvest_season = season_type::AUTUMN;
debugmsg( "Invalid harvest season \"%s\" in \"%s\".", season.c_str(), id.c_str() );
}
}
bash.load( jo, "bash", false );
deconstruct.load( jo, "deconstruct", false );
}
void mission_type::load( JsonObject &jo, const std::string & )
{
mandatory( jo, was_loaded, "name", name, translated_string_reader );
mandatory( jo, was_loaded, "difficulty", difficulty );
mandatory( jo, was_loaded, "value", value );
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 );
assign_function( jo, "start", start, mission_function_map );
assign_function( jo, "end", end, mission_function_map );
assign_function( jo, "fail", fail, mission_function_map );
if( jo.has_int( "deadline_low" ) ) {
deadline_low = DAYS( jo.get_int( "deadline_low" ) );
}
if( jo.has_int( "deadline_high" ) ) {
deadline_high = DAYS( jo.get_int( "deadline_high" ) );
}
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( jo.has_member( "followup" ) ) {
follow_up = mission_type_id( jo.get_string( "followup" ) );
}
if( jo.has_member( "destination" ) ) {
target_id = oter_id( jo.get_string( "destination" ) );
}
}
void load_furniture(JsonObject &jsobj)
{
if ( furnlist.empty() ) {
furn_t new_null = null_furniture_t();
furnmap[new_null.id] = new_null;
furnlist.push_back(new_null);
}
furn_t new_furniture;
new_furniture.id = jsobj.get_string("id");
if ( new_furniture.id == "f_null" ) {
return;
}
new_furniture.name = _(jsobj.get_string("name").c_str());
new_furniture.load_symbol( jsobj );
new_furniture.movecost = jsobj.get_int("move_cost_mod");
new_furniture.move_str_req = jsobj.get_int("required_str");
new_furniture.max_volume = jsobj.get_int("max_volume", MAX_VOLUME_IN_SQUARE);
new_furniture.crafting_pseudo_item = jsobj.get_string("crafting_pseudo_item", "");
new_furniture.transparent = false;
for( auto & flag : jsobj.get_string_array( "flags" ) ) {
new_furniture.set_flag( flag );
}
if(jsobj.has_member("examine_action")) {
std::string function_name = jsobj.get_string("examine_action");
new_furniture.examine = iexamine_function_from_string(function_name);
} else {
//If not specified, default to no action
new_furniture.examine = iexamine_function_from_string("none");
}
new_furniture.open = "";
if ( jsobj.has_member("open") ) {
new_furniture.open = jsobj.get_string("open");
}
new_furniture.close = "";
if ( jsobj.has_member("close") ) {
new_furniture.close = jsobj.get_string("close");
}
new_furniture.bash.load(jsobj, "bash", true);
new_furniture.deconstruct.load(jsobj, "deconstruct", true);
new_furniture.loadid = furn_id( furnlist.size() );
furnmap[new_furniture.id] = new_furniture;
furnlist.push_back(new_furniture);
}
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 Item_factory::load_item_category(JsonObject &jo)
{
const std::string id = jo.get_string("id");
// reuse an existing definition,
// override the name and the sort_rank if
// these are present in the json
item_category &cat = m_categories[id];
cat.id = id;
if(jo.has_member("name")) {
cat.name = _(jo.get_string("name").c_str());
}
if(jo.has_member("sort_rank")) {
cat.sort_rank = jo.get_int("sort_rank");
}
}
void map_data_common_t::load_symbol( JsonObject &jo )
{
load_season_array( *jo.get_raw( "symbol" ), symbol_, string_to_symbol );
const bool has_color = jo.has_member( "color" );
const bool has_bgcolor = jo.has_member( "bgcolor" );
if( has_color && has_bgcolor ) {
jo.throw_error( "Found both color and bgcolor, only one of these is allowed." );
} else if( has_color ) {
load_season_array( *jo.get_raw( "color" ), color_, color_from_json );
} else if( has_bgcolor ) {
load_season_array( *jo.get_raw( "bgcolor" ), color_, bgcolor_from_json );
} else {
jo.throw_error( "Missing member: one of: \"color\", \"bgcolor\" must exist." );
}
}
void trap::load( JsonObject &jo )
{
std::unique_ptr<trap> trap_ptr( new trap() );
trap &t = *trap_ptr;
if( jo.has_member( "drops" ) ) {
JsonArray drops_list = jo.get_array( "drops" );
while( drops_list.has_more() ) {
t.components.push_back( drops_list.next_string() );
}
}
t.name = jo.get_string( "name" );
if( !t.name.empty() ) {
t.name = _( t.name.c_str() );
}
t.id = trap_str_id( jo.get_string( "id" ) );
t.loadid = trap_id( traplist.size() );
t.color = color_from_string( jo.get_string( "color" ) );
t.sym = jo.get_string( "symbol" ).at( 0 );
t.visibility = jo.get_int( "visibility" );
t.avoidance = jo.get_int( "avoidance" );
t.difficulty = jo.get_int( "difficulty" );
t.act = trap_function_from_string( jo.get_string( "action" ) );
t.benign = jo.get_bool( "benign", false );
t.funnel_radius_mm = jo.get_int( "funnel_radius", 0 );
t.trigger_weight = jo.get_int( "trigger_weight", -1 );
trapmap[t.id] = t.loadid;
traplist.push_back( &t );
trap_ptr.release();
if( t.is_funnel() ) {
funnel_traps.push_back( &t );
}
}
////////////////// mission.h
////
void mission::deserialize(JsonIn &jsin)
{
JsonObject jo = jsin.get_object();
if (jo.has_member("type_id")) {
type = &(g->mission_types[jo.get_int("type_id")]);
}
jo.read("description", description);
jo.read("failed", failed);
jo.read("value", value);
jo.read("reward", reward);
jo.read("uid", uid );
JsonArray ja = jo.get_array("target");
if (ja.size() == 2) {
target.x = ja.get_int(0);
target.y = ja.get_int(1);
}
follow_up = mission_id(jo.get_int("follow_up", follow_up));
item_id = itype_id(jo.get_string("item_id", item_id));
jo.read("deadline", deadline );
jo.read("step", step );
jo.read("count", count );
jo.read("npc_id", npc_id );
jo.read("good_fac_id", good_fac_id );
jo.read("bad_fac_id", bad_fac_id );
}
void add_if_exists( JsonObject &jo, Container &cont, bool was_loaded,
const std::string &json_key, const typename Container::key_type &id )
{
if( jo.has_member( json_key ) ) {
mandatory( jo, was_loaded, json_key, cont[id] );
}
}
void load_trap(JsonObject &jo)
{
std::vector<std::string> drops;
if(jo.has_member("drops")) {
JsonArray drops_list = jo.get_array("drops");
while(drops_list.has_more()) {
drops.push_back(drops_list.next_string());
}
}
std::string name = jo.get_string("name");
if (!name.empty()) {
name = _(name.c_str());
}
trap *new_trap = new trap(
jo.get_string("id"), // "tr_beartrap"
traplist.size(), // tr_beartrap
name, // "bear trap"
color_from_string(jo.get_string("color")),
jo.get_string("symbol").at(0),
jo.get_int("visibility"),
jo.get_int("avoidance"),
jo.get_int("difficulty"),
trap_function_from_string(jo.get_string("action")),
drops
);
new_trap->benign = jo.get_bool("benign", false);
new_trap->funnel_radius_mm = jo.get_int("funnel_radius", 0);
new_trap->trigger_weight = jo.get_int("trigger_weight", -1);
trapmap[new_trap->id] = new_trap->loadid;
traplist.push_back(new_trap);
}
void furn_t::load( JsonObject &jo )
{
mandatory( jo, was_loaded, "name", name, translated_string_reader );
mandatory( jo, was_loaded, "move_cost_mod", movecost );
mandatory( jo, was_loaded, "required_str", move_str_req );
optional( jo, was_loaded, "max_volume", max_volume, legacy_volume_reader, DEFAULT_MAX_VOLUME_IN_SQUARE );
optional( jo, was_loaded, "crafting_pseudo_item", crafting_pseudo_item, "" );
load_symbol( jo );
transparent = false;
for( auto & flag : jo.get_string_array( "flags" ) ) {
set_flag( flag );
}
if( jo.has_member( "examine_action" ) ) {
examine = iexamine_function_from_string( jo.get_string( "examine_action" ) );
} else {
examine = iexamine_function_from_string( "none" );
}
optional( jo, was_loaded, "open", open, string_id_reader<furn_t> {}, NULL_ID );
optional( jo, was_loaded, "close", close, string_id_reader<furn_t> {}, NULL_ID );
bash.load( jo, "bash", true );
deconstruct.load( jo, "deconstruct", true );
}
void MonsterGenerator::load_species(JsonObject &jo)
{
// id, flags, triggers (anger, placate, fear)
std::string sid;
if (jo.has_member("id")) {
sid = jo.get_string("id");
int species_num = mon_species.size();
if (mon_species.count(sid) > 0) {
species_num = mon_species[sid]->short_id; // Keep it or weird things may happen
delete mon_species[sid];
}
std::set<std::string> sflags, sanger, sfear, splacate;
sflags = jo.get_tags("flags");
sanger = jo.get_tags("anger_triggers");
sfear = jo.get_tags("fear_triggers");
splacate = jo.get_tags("placate_triggers");
std::set<m_flag> flags = get_set_from_tags(sflags, flag_map, MF_NULL);
std::set<monster_trigger> anger, fear, placate;
anger = get_set_from_tags(sanger, trigger_map, MTRIG_NULL);
fear = get_set_from_tags(sfear, trigger_map, MTRIG_NULL);
placate = get_set_from_tags(splacate, trigger_map, MTRIG_NULL);
species_type *new_species = new species_type(species_num, sid, flags, anger, fear, placate);
mon_species[sid] = new_species;
}
}
void ter_t::load( JsonObject &jo, const std::string &src )
{
map_data_common_t::load( jo, src );
mandatory( jo, was_loaded, "name", name_ );
mandatory( jo, was_loaded, "move_cost", movecost );
optional( jo, was_loaded, "max_volume", max_volume, legacy_volume_reader, DEFAULT_MAX_VOLUME_IN_SQUARE );
optional( jo, was_loaded, "trap", trap_id_str );
load_symbol( jo );
trap = tr_null;
transparent = false;
connect_group = TERCONN_NONE;
for( auto &flag : jo.get_string_array( "flags" ) ) {
set_flag( flag );
}
// connect_group is initialized to none, then terrain flags are set, then finally
// connections from JSON are set. This is so that wall flags can set wall connections
// but can be overridden by explicit connections in JSON.
if( jo.has_member( "connects_to" ) ) {
set_connects( jo.get_string( "connects_to" ) );
}
optional( jo, was_loaded, "open", open, ter_str_id::NULL_ID() );
optional( jo, was_loaded, "close", close, ter_str_id::NULL_ID() );
optional( jo, was_loaded, "transforms_into", transforms_into, ter_str_id::NULL_ID() );
optional( jo, was_loaded, "roof", roof, ter_str_id::NULL_ID() );
bash.load( jo, "bash", false );
deconstruct.load( jo, "deconstruct", false );
}
void load_effect_type(JsonObject &jo)
{
effect_type new_etype;
new_etype.id = jo.get_string("id");
new_etype.name = jo.get_string("name", "");
new_etype.desc = jo.get_string("desc", "");
if(jo.has_member("rating")) {
std::string r = jo.get_string("rating");
if(r == "good") {
new_etype.rating = e_good;
} else if(r == "neutral" ) {
new_etype.rating = e_neutral;
} else if(r == "bad" ) {
new_etype.rating = e_bad;
} else if(r == "mixed" ) {
new_etype.rating = e_mixed;
} else {
new_etype.rating = e_neutral;
}
} else {
new_etype.rating = e_neutral;
}
new_etype.apply_message = jo.get_string("apply_message", "");
new_etype.remove_message = jo.get_string("remove_message", "");
new_etype.apply_memorial_log = jo.get_string("apply_memorial_log", "");
new_etype.remove_memorial_log = jo.get_string("remove_memorial_log", "");
new_etype.max_intensity = jo.get_int("max_intensity", 1);
effect_types[new_etype.id] = new_etype;
}
void game::load_trap(JsonObject &jo)
{
std::vector<std::string> drops;
if(jo.has_member("drops")) {
JsonArray drops_list = jo.get_array("drops");
while(drops_list.has_more()) {
drops.push_back(drops_list.next_string());
}
}
trap *new_trap = new trap(
jo.get_string("id"), // "tr_beartrap"
g->traps.size(), // tr_beartrap
jo.get_string("name"), // "bear trap"
color_from_string(jo.get_string("color")),
jo.get_string("symbol").at(0),
jo.get_int("visibility"),
jo.get_int("avoidance"),
jo.get_int("difficulty"),
trap_function_from_string(jo.get_string("player_action")),
trap_function_mon_from_string(jo.get_string("monster_action")),
drops
);
new_trap->benign = jo.get_bool("benign", false);
new_trap->funnel_radius_mm = jo.get_int("funnel_radius", 0);
trapmap[new_trap->id] = new_trap->loadid;
traps.push_back(new_trap);
}
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());
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->item_chance = jo.get_int("item_chance", 0);
newmon->hp = jo.get_int("hp", 0);
newmon->sp_freq = jo.get_int("special_freq", 0);
newmon->luminance = jo.get_float("luminance", 0);
newmon->dies = get_death_functions(jo, "death_function");
newmon->sp_attack = get_attack_function(jo, "special_attack");
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;
}
}
void gun_actor::load( JsonObject &obj )
{
// Mandatory
gun_type = obj.get_string( "gun_type" );
ammo_type = obj.get_string( "ammo_type" );
JsonArray jarr = obj.get_array( "fake_skills" );
while( jarr.has_more() ) {
JsonArray cur = jarr.next_array();
fake_skills[skill_id( cur.get_string( 0 ) )] = cur.get_int( 1 );
}
range = obj.get_float( "range" );
description = obj.get_string( "description" );
move_cost = obj.get_int( "move_cost" );
targeting_cost = obj.get_int( "targeting_cost" );
// Optional:
max_ammo = obj.get_int( "max_ammo", INT_MAX );
fake_str = obj.get_int( "fake_str", 8 );
fake_dex = obj.get_int( "fake_dex", 8 );
fake_int = obj.get_int( "fake_int", 8 );
fake_per = obj.get_int( "fake_per", 8 );
require_targeting_player = obj.get_bool( "require_targeting_player", true );
require_targeting_npc = obj.get_bool( "require_targeting_npc", false );
require_targeting_monster = obj.get_bool( "require_targeting_monster", false );
targeting_timeout = obj.get_int( "targeting_timeout", 8 );
targeting_timeout_extend = obj.get_int( "targeting_timeout_extend", 3 );
burst_limit = obj.get_int( "burst_limit", INT_MAX );
laser_lock = obj.get_bool( "laser_lock", false );
range_no_burst = obj.get_float( "range_no_burst", range + 1 );
if( obj.has_member( "targeting_sound" ) || obj.has_member( "targeting_volume" ) ) {
// Both or neither, but not just one
targeting_sound = obj.get_string( "targeting_sound" );
targeting_volume = obj.get_int( "targeting_volume" );
}
// Sound of no ammo
no_ammo_sound = obj.get_string( "no_ammo_sound", "" );
}
void Messages::deserialize( JsonObject &json )
{
if( json.has_member( "player_messages" ) ) {
JsonObject obj = json.get_object( "player_messages" );
obj.read( "messages", player_messages.messages );
obj.read( "curmes", player_messages.curmes );
}
}
void snippet_library::add_snippet_from_json( const std::string &category, JsonObject &jo )
{
const std::string text = _( jo.get_string( "text" ).c_str() );
const int hash = add_snippet( category, text );
if( jo.has_member( "id" ) ) {
const std::string id = jo.get_string( "id" );
snippets_by_id[id] = hash;
}
}
void load_monster_adjustment( JsonObject &jsobj )
{
monster_adjustment adj;
adj.species = species_id( jsobj.get_string( "species" ) );
if( jsobj.has_member( "stat" ) ) {
JsonObject stat = jsobj.get_object( "stat" );
stat.read( "name", adj.stat );
stat.read( "modifier", adj.stat_adjust );
}
if( jsobj.has_member( "flag" ) ) {
JsonObject flag = jsobj.get_object( "flag" );
flag.read( "name", adj.flag );
flag.read( "value", adj.flag_val );
}
if( jsobj.has_member( "special" ) ) {
jsobj.read( "special", adj.special );
}
adjustments.push_back( adj );
}
void Messages::deserialize( JsonObject &json )
{
if (!json.has_member("player_messages")) {
return;
}
JsonObject obj = json.get_object( "player_messages" );
obj.read( "messages", player_messages.impl_->messages );
obj.read( "curmes", player_messages.impl_->curmes );
}
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;
}
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 mutation_branch::add_entry( Trait_group &tg, JsonObject &obj )
{
std::unique_ptr<Trait_creation_data> ptr;
int probability = obj.get_int( "prob", 100 );
JsonArray jarr;
if( obj.has_member( "collection" ) ) {
ptr.reset( new Trait_group_collection( probability ) );
jarr = obj.get_array( "collection" );
} else if( obj.has_member( "distribution" ) ) {
ptr.reset( new Trait_group_distribution( probability ) );
jarr = obj.get_array( "distribution" );
}
if( ptr ) {
Trait_group &tg2 = dynamic_cast<Trait_group &>( *ptr );
while( jarr.has_more() ) {
JsonObject job2 = jarr.next_object();
add_entry( tg2, job2 );
}
tg.add_entry( ptr );
return;
}
if( obj.has_member( "trait" ) ) {
trait_id id( obj.get_string( "trait" ) );
ptr.reset( new Single_trait_creator( id, probability ) );
} else if( obj.has_member( "group" ) ) {
ptr.reset( new Trait_group_creator( trait_group::Trait_group_tag( obj.get_string( "group" ) ),
probability ) );
}
if( !ptr ) {
return;
}
tg.add_entry( ptr );
}
