/**
* Reads in a vehicle part from a JsonObject.
*/
void vpart_info::load( JsonObject &jo, const std::string &src )
{
vpart_info def;
if( jo.has_string( "copy-from" ) ) {
auto const base = vpart_info_all.find( vpart_id( jo.get_string( "copy-from" ) ) );
auto const ab = abstract_parts.find( vpart_id( jo.get_string( "copy-from" ) ) );
if( base != vpart_info_all.end() ) {
def = base->second;
} else if( ab != abstract_parts.end() ) {
def = ab->second;
} else {
deferred.emplace_back( jo.str(), src );
return;
}
}
if( jo.has_string( "abstract" ) ) {
def.id = vpart_id( jo.get_string( "abstract" ) );
} else {
def.id = vpart_id( jo.get_string( "id" ) );
}
assign( jo, "name", def.name_ );
assign( jo, "item", def.item );
assign( jo, "location", def.location );
assign( jo, "durability", def.durability );
assign( jo, "damage_modifier", def.dmg_mod );
assign( jo, "power", def.power );
assign( jo, "epower", def.epower );
assign( jo, "fuel_type", def.fuel_type );
assign( jo, "default_ammo", def.default_ammo );
assign( jo, "folded_volume", def.folded_volume );
assign( jo, "size", def.size );
assign( jo, "difficulty", def.difficulty );
assign( jo, "bonus", def.bonus );
assign( jo, "flags", def.flags );
if( jo.has_member( "requirements" ) ) {
auto reqs = jo.get_object( "requirements" );
parse_vp_reqs( reqs, def.id.str(), "install", def.install_reqs, def.install_skills, def.install_moves );
parse_vp_reqs( reqs, def.id.str(), "removal", def.removal_reqs, def.removal_skills, def.removal_moves );
parse_vp_reqs( reqs, def.id.str(), "repair", def.repair_reqs, def.repair_skills, def.repair_moves );
def.legacy = false;
}
if( jo.has_member( "symbol" ) ) {
def.sym = jo.get_string( "symbol" )[ 0 ];
}
if( jo.has_member( "broken_symbol" ) ) {
def.sym_broken = jo.get_string( "broken_symbol" )[ 0 ];
}
if( jo.has_member( "color" ) ) {
def.color = color_from_string( jo.get_string( "color" ) );
}
if( jo.has_member( "broken_color" ) ) {
def.color_broken = color_from_string( jo.get_string( "broken_color" ) );
}
if( jo.has_member( "breaks_into" ) ) {
JsonIn& stream = *jo.get_raw( "breaks_into" );
def.breaks_into_group = item_group::load_item_group( stream, "collection" );
}
auto qual = jo.get_array( "qualities" );
if( !qual.empty() ) {
def.qualities.clear();
while( qual.has_more() ) {
auto pair = qual.next_array();
def.qualities[ quality_id( pair.get_string( 0 ) ) ] = pair.get_int( 1 );
}
}
if( jo.has_member( "damage_reduction" ) ) {
JsonObject dred = jo.get_object( "damage_reduction" );
def.damage_reduction = load_damage_array( dred );
} else {
def.damage_reduction.fill( 0.0f );
}
if( jo.has_string( "abstract" ) ) {
abstract_parts[def.id] = def;
} else {
vpart_info_all[def.id] = def;
}
}
void MonsterGroupManager::LoadMonsterGroup( JsonObject &jo )
{
float mon_upgrade_factor = get_option<float>( "MONSTER_UPGRADE_FACTOR" );
MonsterGroup g;
g.name = mongroup_id( jo.get_string( "name" ) );
bool extending = false; //If already a group with that name, add to it instead of overwriting it
if( monsterGroupMap.count( g.name ) != 0 && !jo.get_bool( "override", false ) ) {
g = monsterGroupMap[g.name];
extending = true;
}
if( !extending
|| jo.has_string( "default" ) ) { //Not mandatory to specify default if extending existing group
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();
}
static const time_duration tdfactor = 1_hours;
time_duration starts = 0_turns;
time_duration ends = 0_turns;
if( mon.has_member( "starts" ) ) {
starts = tdfactor * mon.get_int( "starts" ) * ( mon_upgrade_factor > 0 ? mon_upgrade_factor : 1 );
}
if( mon.has_member( "ends" ) ) {
ends = tdfactor * mon.get_int( "ends" ) * ( mon_upgrade_factor > 0 ? mon_upgrade_factor : 1 );
}
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() ) );
assign( jo, "replacement_time", g.monster_group_time, false, 1_days );
g.is_safe = jo.get_bool( "is_safe", false );
g.freq_total = jo.get_int( "freq_total", ( extending ? g.freq_total : 1000 ) );
if( jo.get_bool( "auto_total", false ) ) { //Fit the max size to the sum of all freqs
int total = 0;
for( MonsterGroupEntry &mon : g.monsters ) {
total += mon.frequency;
}
g.freq_total = total;
}
monsterGroupMap[g.name] = g;
}
void load_martial_art(JsonObject &jo)
{
martialart ma;
JsonArray jsarr;
ma.id = jo.get_string("id");
ma.name = _(jo.get_string("name").c_str());
ma.description = _(jo.get_string("description").c_str());
jsarr = jo.get_array("static_buffs");
while (jsarr.has_more()) {
JsonObject jsobj = jsarr.next_object();
ma.static_buffs.push_back(load_buff(jsobj));
}
jsarr = jo.get_array("onmove_buffs");
while (jsarr.has_more()) {
JsonObject jsobj = jsarr.next_object();
ma.onmove_buffs.push_back(load_buff(jsobj));
}
jsarr = jo.get_array("onhit_buffs");
while (jsarr.has_more()) {
JsonObject jsobj = jsarr.next_object();
ma.onhit_buffs.push_back(load_buff(jsobj));
}
jsarr = jo.get_array("onattack_buffs");
while (jsarr.has_more()) {
JsonObject jsobj = jsarr.next_object();
ma.onattack_buffs.push_back(load_buff(jsobj));
}
jsarr = jo.get_array("ondodge_buffs");
while (jsarr.has_more()) {
JsonObject jsobj = jsarr.next_object();
ma.ondodge_buffs.push_back(load_buff(jsobj));
}
jsarr = jo.get_array("onblock_buffs");
while (jsarr.has_more()) {
JsonObject jsobj = jsarr.next_object();
ma.onblock_buffs.push_back(load_buff(jsobj));
}
jsarr = jo.get_array("ongethit_buffs");
while (jsarr.has_more()) {
JsonObject jsobj = jsarr.next_object();
ma.onblock_buffs.push_back(load_buff(jsobj));
}
ma.techniques = jo.get_tags("techniques");
ma.weapons = jo.get_tags("weapons");
ma.leg_block = jo.get_int("leg_block", 99);
ma.arm_block = jo.get_int("arm_block", 99);
ma.arm_block_with_bio_armor_arms = jo.get_bool("arm_block_with_bio_armor_arms", false);
ma.leg_block_with_bio_armor_legs = jo.get_bool("leg_block_with_bio_armor_legs", false);
martialarts[ma.id] = ma;
}
/**
* Reads in a vehicle part from a JsonObject.
*/
void game::load_vehiclepart(JsonObject &jo)
{
vpart_info next_part;
next_part.id = jo.get_string("id");
next_part.name = _(jo.get_string("name").c_str());
next_part.sym = jo.get_string("symbol")[0];
next_part.color = color_from_string(jo.get_string("color"));
next_part.sym_broken = jo.get_string("broken_symbol")[0];
next_part.color_broken = color_from_string(jo.get_string("broken_color"));
next_part.dmg_mod = jo.has_member("damage_modifier") ? jo.get_int("damage_modifier") : 100;
next_part.durability = jo.get_int("durability");
next_part.power = jo.get_int("power", 0);
next_part.epower = jo.get_int("epower", 0);
next_part.folded_volume = jo.get_int("folded_volume", 0);
next_part.range = jo.get_int( "range", 12 );
//Handle the par1 union as best we can by accepting any ONE of its elements
int element_count = (jo.has_member("par1") ? 1 : 0)
+ (jo.has_member("size") ? 1 : 0)
+ (jo.has_member("wheel_width") ? 1 : 0)
+ (jo.has_member("bonus") ? 1 : 0);
if(element_count == 0) {
//If not specified, assume 0
next_part.par1 = 0;
} else if(element_count == 1) {
if(jo.has_member("par1")) {
next_part.par1 = jo.get_int("par1");
} else if(jo.has_member("size")) {
next_part.par1 = jo.get_int("size");
} else if(jo.has_member("wheel_width")) {
next_part.par1 = jo.get_int("wheel_width");
} else { //bonus
next_part.par1 = jo.get_int("bonus");
}
} else {
//Too many
debugmsg("Error parsing vehicle part '%s': \
Use AT MOST one of: par1, power, size, wheel_width, bonus",
next_part.name.c_str());
//Keep going to produce more messages if other parts are wrong
next_part.par1 = 0;
}
next_part.fuel_type = jo.has_member("fuel_type") ? jo.get_string("fuel_type") : "NULL";
next_part.item = jo.get_string("item");
next_part.difficulty = jo.get_int("difficulty");
next_part.location = jo.has_member("location") ? jo.get_string("location") : "";
next_part.bitflags = 0;
JsonArray jarr = jo.get_array("flags");
std::string nstring = "";
while (jarr.has_more()) {
nstring = jarr.next_string();
next_part.flags.insert(nstring);
if ( vpart_bitflag_map.find(nstring) != vpart_bitflag_map.end() ) {
next_part.bitflags |= mfb( vpart_bitflag_map.find(nstring)->second );
}
}
if (jo.has_member("FOLDABLE") && next_part.folded_volume == 0){
debugmsg("Error: folded part %s has a volume of 0!", next_part.name.c_str());
}
JsonArray breaks_into = jo.get_array("breaks_into");
while(breaks_into.has_more()) {
JsonObject next_entry = breaks_into.next_object();
break_entry next_break_entry;
next_break_entry.item_id = next_entry.get_string("item");
next_break_entry.min = next_entry.get_int("min");
next_break_entry.max = next_entry.get_int("max");
//Sanity check
if(next_break_entry.max < next_break_entry.min) {
debugmsg("For vehicle part %s: breaks_into item '%s' has min (%d) > max (%d)!",
next_part.name.c_str(), next_break_entry.item_id.c_str(),
next_break_entry.min, next_break_entry.max);
}
next_part.breaks_into.push_back(next_break_entry);
}
//Calculate and cache z-ordering based off of location
// list_order is used when inspecting the vehicle
if(next_part.location == "on_roof") {
next_part.z_order = 9;
next_part.list_order = 3;
} else if(next_part.location == "on_cargo") {
next_part.z_order = 8;
next_part.list_order = 6;
} else if(next_part.location == "center") {
next_part.z_order = 7;
next_part.list_order = 7;
} else if(next_part.location == "under") {
//Have wheels show up over frames
next_part.z_order = 6;
next_part.list_order = 10;
} else if(next_part.location == "structure") {
next_part.z_order = 5;
next_part.list_order = 1;
} else if(next_part.location == "engine_block") {
//Should be hidden by frames
next_part.z_order = 4;
next_part.list_order = 8 ;
} else if (next_part.location == "on_battery_mount"){
//Should be hidden by frames
next_part.z_order = 3;
next_part.list_order = 10;
} else if(next_part.location == "fuel_source") {
//Should be hidden by frames
next_part.z_order = 3;
next_part.list_order = 9;
} else if(next_part.location == "roof") {
//Shouldn't be displayed
next_part.z_order = -1;
next_part.list_order = 4;
} else if(next_part.location == "armor") {
//Shouldn't be displayed (the color is used, but not the symbol)
next_part.z_order = -2;
next_part.list_order = 2;
} else {
//Everything else
next_part.z_order = 0;
next_part.list_order = 5;
}
if (vehicle_part_types.count(next_part.id) > 0) {
next_part.loadid = vehicle_part_types[next_part.id].loadid;
vehicle_part_int_types[next_part.loadid] = next_part;
} else {
next_part.loadid = vehicle_part_int_types.size();
vehicle_part_int_types.push_back(next_part);
}
vehicle_part_types[next_part.id] = next_part;
}
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->def_chance = jo.get_int("special_when_hit_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");
newmon->sp_defense = get_defense_function(jo, "special_when_hit");
std::set<std::string> flags, anger_trig, placate_trig, fear_trig, cats;
flags = jo.get_tags("flags");
anger_trig = jo.get_tags("anger_triggers");
placate_trig = jo.get_tags("placate_triggers");
fear_trig = jo.get_tags("fear_triggers");
newmon->flags = get_set_from_tags(flags, flag_map, MF_NULL);
newmon->anger = get_set_from_tags(anger_trig, trigger_map, MTRIG_NULL);
newmon->fear = get_set_from_tags(fear_trig, trigger_map, MTRIG_NULL);
newmon->placate = get_set_from_tags(placate_trig, trigger_map, MTRIG_NULL);
mon_templates[mid] = newmon;
}
}
//Basic Init, create the font, backbuffer, etc
WINDOW *curses_init(void)
{
// _windows = new WINDOW[20]; //initialize all of our variables
lastchar=-1;
inputdelay=-1;
int fontsize = 16;
std::string typeface;
char * typeface_c;
int map_fontwidth = 8;
int map_fontheight = 16;
int map_fontsize = 16;
std::string map_typeface;
bool fontblending;
std::ifstream jsonstream(FILENAMES["fontdata"].c_str(), std::ifstream::binary);
if (jsonstream.good()) {
JsonIn json(jsonstream);
JsonObject config = json.get_object();
// fontsize, fontblending, map_* are ignored in wincurse.
fontwidth = config.get_int("fontwidth", fontwidth);
fontheight = config.get_int("fontheight", fontheight);
typeface = config.get_string("typeface", typeface);
jsonstream.close();
} else { // User fontdata is missed. Try to load legacy fontdata.
// Get and save all values. With unused.
std::ifstream InStream(FILENAMES["legacy_fontdata"].c_str(), std::ifstream::binary);
if(InStream.good()) {
JsonIn jIn(InStream);
JsonObject config = jIn.get_object();
fontwidth = config.get_int("fontwidth", fontwidth);
fontheight = config.get_int("fontheight", fontheight);
fontsize = config.get_int("fontsize", fontsize);
typeface = config.get_string("typeface", typeface);
map_fontwidth = config.get_int("map_fontwidth", fontwidth);
map_fontheight = config.get_int("map_fontheight", fontheight);
map_fontsize = config.get_int("map_fontsize", fontsize);
map_typeface = config.get_string("map_typeface", typeface);
InStream.close();
// Save legacy as user fontdata.
assure_dir_exist(FILENAMES["config_dir"]);
std::ofstream OutStream(FILENAMES["fontdata"].c_str(), std::ofstream::binary);
if(!OutStream.good()) {
DebugLog() << "Can't save user fontdata file.\n"
<< "Check permissions for: " << FILENAMES["fontdata"].c_str();
return NULL;
}
JsonOut jOut(OutStream, true); // pretty-print
jOut.start_object();
jOut.member("fontblending", fontblending);
jOut.member("fontwidth", fontwidth);
jOut.member("fontheight", fontheight);
jOut.member("fontsize", fontsize);
jOut.member("typeface", typeface);
jOut.member("map_fontwidth", map_fontwidth);
jOut.member("map_fontheight", map_fontheight);
jOut.member("map_fontsize", map_fontsize);
jOut.member("map_typeface", map_typeface);
jOut.end_object();
OutStream << "\n";
OutStream.close();
} else {
DebugLog() << "Can't load fontdata files.\n"
<< "Check permissions for:\n" << FILENAMES["legacy_fontdata"].c_str() << "\n"
<< FILENAMES["fontdata"].c_str() << "\n";
return NULL;
}
}
typeface_c = new char [typeface.size()+1];
strncpy (typeface_c, typeface.c_str(), typeface.size());
typeface_c[typeface.size()] = '\0';
halfwidth=fontwidth / 2;
halfheight=fontheight / 2;
WindowWidth= OPTIONS["TERMINAL_X"] * fontwidth;
WindowHeight = OPTIONS["TERMINAL_Y"] * fontheight;
WinCreate(); //Create the actual window, register it, etc
timeBeginPeriod(1); // Set Sleep resolution to 1ms
CheckMessages(); //Let the message queue handle setting up the window
WindowDC = GetDC(WindowHandle);
backbuffer = CreateCompatibleDC(WindowDC);
BITMAPINFO bmi = BITMAPINFO();
bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmi.bmiHeader.biWidth = WindowWidth;
bmi.bmiHeader.biHeight = -WindowHeight;
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biBitCount = 8;
bmi.bmiHeader.biCompression = BI_RGB; // Raw RGB
bmi.bmiHeader.biSizeImage = WindowWidth * WindowHeight * 1;
bmi.bmiHeader.biClrUsed = 16; // Colors in the palette
bmi.bmiHeader.biClrImportant = 16; // Colors in the palette
backbit = CreateDIBSection(0, &bmi, DIB_RGB_COLORS, (void**)&dcbits, NULL, 0);
DeleteObject(SelectObject(backbuffer, backbit));//load the buffer into DC
// Load private fonts
if (SetCurrentDirectory("data\\font")){
WIN32_FIND_DATA findData;
for (HANDLE findFont = FindFirstFile(".\\*", &findData); findFont != INVALID_HANDLE_VALUE; )
{
if (!(findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)){ // Skip folders
AddFontResourceExA(findData.cFileName, FR_PRIVATE,NULL);
}
if (!FindNextFile(findFont, &findData)){
FindClose(findFont);
break;
}
}
SetCurrentDirectory("..\\..");
}
// Use desired font, if possible
font = CreateFont(fontheight, fontwidth, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE,
ANSI_CHARSET, OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,
PROOF_QUALITY, FF_MODERN, typeface_c);
SetBkMode(backbuffer, TRANSPARENT);//Transparent font backgrounds
SelectObject(backbuffer, font);//Load our font into the DC
// WindowCount=0;
init_colors();
delete[] typeface_c;
mainwin = newwin(OPTIONS["TERMINAL_Y"],OPTIONS["TERMINAL_X"],0,0);
return mainwin; //create the 'stdscr' window and return its ref
}
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.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;
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.deconstruct.load(jsobj, "deconstruct", true);
new_furniture.loadid = furnlist.size();
furnmap[new_furniture.id] = new_furniture;
furnlist.push_back(new_furniture);
}
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_trait_group( JsonObject &jsobj )
{
const trait_group::Trait_group_tag group_id( jsobj.get_string( "id" ) );
const std::string subtype = jsobj.get_string( "subtype", "old" );
load_trait_group( jsobj, group_id, subtype );
}
void input_manager::load(const std::string &file_name, bool is_user_preferences)
{
std::ifstream data_file(file_name.c_str(), std::ifstream::in | std::ifstream::binary);
if(!data_file.good()) {
// Only throw if this is the first file to load, that file _must_ exist,
// otherwise the keybindings can not be read at all.
if (action_contexts.empty()) {
throw "Could not read " + file_name;
}
return;
}
JsonIn jsin(data_file);
//Crawl through once and create an entry for every definition
jsin.start_array();
while (!jsin.end_array()) {
// JSON object representing the action
JsonObject action = jsin.get_object();
const std::string action_id = action.get_string("id");
const std::string context = action.get_string("category", default_context_id);
t_actions &actions = action_contexts[context];
if (!is_user_preferences && action.has_member("name")) {
// Action names are not user preferences. Some experimental builds
// post-0.A had written action names into the user preferences
// config file. Any names that exist in user preferences will be
// ignored.
actions[action_id].name = action.get_string("name");
}
// Iterate over the bindings JSON array
JsonArray bindings = action.get_array("bindings");
t_input_event_list events;
while (bindings.has_more()) {
JsonObject keybinding = bindings.next_object();
std::string input_method = keybinding.get_string("input_method");
input_event new_event;
if(input_method == "keyboard") {
new_event.type = CATA_INPUT_KEYBOARD;
} else if(input_method == "gamepad") {
new_event.type = CATA_INPUT_GAMEPAD;
} else if(input_method == "mouse") {
new_event.type = CATA_INPUT_MOUSE;
}
if (keybinding.has_array("key")) {
JsonArray keys = keybinding.get_array("key");
while (keys.has_more()) {
new_event.sequence.push_back(
get_keycode(keys.next_string())
);
}
} else { // assume string if not array, and throw if not string
new_event.sequence.push_back(
get_keycode(keybinding.get_string("key"))
);
}
events.push_back(new_event);
}
// An invariant of this class is that user-created, local keybindings
// with an empty set of input_events do not exist in the
// action_contexts map. In prior versions of this class, this was not
// true, so users of experimental builds post-0.A will have empty
// local keybindings saved in their keybindings.json config.
//
// To be backwards compatible with keybindings.json from prior
// experimental builds, we will detect user-created, local keybindings
// with empty input_events and disregard them. When keybindings are
// later saved, these remnants won't be saved.
if (!is_user_preferences ||
!events.empty() ||
context == default_context_id ||
actions.count(action_id) > 0) {
// In case this is the second file containing user preferences,
// this replaces the default bindings with the user's preferences.
action_attributes &attributes = actions[action_id];
attributes.input_events = events;
if (action.has_member("is_user_created")) {
attributes.is_user_created = action.get_bool("is_user_created");
}
}
}
}
void load_terrain(JsonObject &jsobj)
{
if ( terlist.empty() ) {
ter_t new_null = null_terrain_t();
termap[new_null.id] = new_null;
terlist.push_back(new_null);
}
ter_t new_terrain;
new_terrain.id = jsobj.get_string("id");
if ( new_terrain.id == "t_null" ) {
return;
}
new_terrain.name = _(jsobj.get_string("name").c_str());
//Special case for the LINE_ symbols
std::string symbol = jsobj.get_string("symbol");
if("LINE_XOXO" == symbol) {
new_terrain.sym = LINE_XOXO;
} else if("LINE_OXOX" == symbol) {
new_terrain.sym = LINE_OXOX;
} else {
new_terrain.sym = symbol.c_str()[0];
}
new_terrain.color = color_from_string(jsobj.get_string("color"));
new_terrain.movecost = jsobj.get_int("move_cost");
if(jsobj.has_member("trap")) {
// Store the string representation of the trap id.
// Overwrites the trap field in set_trap_ids() once ids are assigned..
new_terrain.trap_id_str = jsobj.get_string("trap");
}
new_terrain.trap = tr_null;
new_terrain.transparent = false;
new_terrain.bitflags = 0;
JsonArray flags = jsobj.get_array("flags");
while(flags.has_more()) {
new_terrain.set_flag(flags.next_string());
}
if(jsobj.has_member("examine_action")) {
std::string function_name = jsobj.get_string("examine_action");
new_terrain.examine = iexamine_function_from_string(function_name);
} else {
//If not specified, default to no action
new_terrain.examine = iexamine_function_from_string("none");
}
new_terrain.open = "";
if ( jsobj.has_member("open") ) {
new_terrain.open = jsobj.get_string("open");
}
new_terrain.close = "";
if ( jsobj.has_member("close") ) {
new_terrain.close = jsobj.get_string("close");
}
new_terrain.bash.load(jsobj, "bash", false);
new_terrain.loadid=terlist.size();
termap[new_terrain.id]=new_terrain;
terlist.push_back(new_terrain);
}
void gun_actor::load_internal( JsonObject &obj, const std::string & )
{
gun_type = obj.get_string( "gun_type" );
obj.read( "ammo_type", ammo_type );
if( obj.has_array( "fake_skills" ) ) {
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 );
}
}
obj.read( "fake_str", fake_str );
obj.read( "fake_dex", fake_dex );
obj.read( "fake_int", fake_int );
obj.read( "fake_per", fake_per );
auto arr = obj.get_array( "ranges" );
while( arr.has_more() ) {
auto mode = arr.next_array();
if( mode.size() < 2 || mode.get_int( 0 ) > mode.get_int( 1 ) ) {
obj.throw_error( "incomplete or invalid range specified", "ranges" );
}
ranges.emplace( std::make_pair<int, int>( mode.get_int( 0 ), mode.get_int( 1 ) ),
gun_mode_id( mode.size() > 2 ? mode.get_string( 2 ) : "" ) );
}
obj.read( "max_ammo", max_ammo );
obj.read( "move_cost", move_cost );
if( obj.read( "description", description ) ) {
description = _( description );
}
if( obj.read( "failure_msg", failure_msg ) ) {
failure_msg = _( failure_msg );
}
if( obj.read( "no_ammo_sound", no_ammo_sound ) ) {
no_ammo_sound = _( no_ammo_sound );
} else {
no_ammo_sound = _( "Click." );
}
obj.read( "targeting_cost", targeting_cost );
obj.read( "require_targeting_player", require_targeting_player );
obj.read( "require_targeting_npc", require_targeting_npc );
obj.read( "require_targeting_monster", require_targeting_monster );
obj.read( "targeting_timeout", targeting_timeout );
obj.read( "targeting_timeout_extend", targeting_timeout_extend );
if( obj.read( "targeting_sound", targeting_sound ) ) {
targeting_sound = _( targeting_sound );
} else {
targeting_sound = _( "Beep." );
}
obj.read( "targeting_volume", targeting_volume );
obj.get_bool( "laser_lock", laser_lock );
obj.read( "require_sunlight", require_sunlight );
}
void item::deserialize(JsonObject &data)
{
init();
clear();
std::string idtmp="";
std::string ammotmp="null";
int lettmp = 0;
std::string corptmp = "null";
int damtmp = 0;
if ( ! data.read( "typeid", idtmp) ) {
debugmsg("Invalid item type: %s ", data.str().c_str() );
idtmp = "null";
}
data.read( "charges", charges );
data.read( "burnt", burnt );
data.read( "poison", poison );
data.read( "owned", owned );
data.read( "bday", bday );
data.read( "mode", mode );
data.read( "mission_id", mission_id );
data.read( "player_id", player_id );
if (!data.read( "corpse", corptmp )) {
int ctmp = -1;
data.read( "corpse", ctmp );
if (ctmp != -1) {
corptmp = legacy_mon_id[ctmp];
} else {
corptmp = "null";
}
}
if (corptmp != "null") {
corpse = GetMType(corptmp);
} else {
corpse = NULL;
}
JsonObject pvars = data.get_object("item_vars");
std::set<std::string> members = pvars.get_member_names();
for ( std::set<std::string>::iterator pvarsit = members.begin();
pvarsit != members.end(); ++pvarsit ) {
if ( pvars.has_string( *pvarsit ) ) {
item_vars[ *pvarsit ] = pvars.get_string( *pvarsit );
}
}
bool old_itype = false;
if ( idtmp == "null" ) {
std::map<std::string, std::string>::const_iterator oldity = item_vars.find("_invalid_itype_");
if ( oldity != item_vars.end() ) {
old_itype = true;
idtmp = oldity->second;
}
}
std::map<std::string, itype*>::const_iterator ity = itypes.find(idtmp);
if ( ity == itypes.end() ) {
item_vars["_invalid_itype_"] = idtmp;
make(NULL);
} else {
if ( old_itype ) {
item_vars.erase( "_invalid_itype_" );
}
make(ity->second);
}
if ( ! data.read( "name", name ) ) {
name=type->name;
}
data.read( "invlet", lettmp );
invlet = char(lettmp);
data.read( "damage", damtmp );
damage = damtmp; // todo: check why this is done after make(), using a tmp variable
data.read( "active", active );
data.read( "item_counter" , item_counter );
data.read( "fridge", fridge );
data.read( "rot", rot );
data.read( "last_rot_check", last_rot_check );
data.read( "curammo", ammotmp );
if ( ammotmp != "null" ) {
curammo = dynamic_cast<it_ammo*>(itypes[ammotmp]);
} else {
curammo = NULL;
}
data.read("item_tags", item_tags);
int tmplum=0;
if ( data.read("light",tmplum) ) {
light=nolight;
int tmpwidth=0;
int tmpdir=0;
data.read("light_width",tmpwidth);
data.read("light_dir",tmpdir);
light.luminance = tmplum;
light.width = (short)tmpwidth;
light.direction = (short)tmpdir;
}
data.read("contents", contents);
data.read("components", components);
}
/**
*Caches a vehicle definition from a JsonObject to be loaded after itypes is initialized.
*/
void vehicle_prototype::load(JsonObject &jo)
{
vehicle_prototype &vproto = vtypes[ vproto_id( jo.get_string( "id" ) ) ];
// If there are already parts defined, this vehicle prototype overrides an existing one.
// If the json contains a name, it means a completely new prototype (replacing the
// original one), therefor the old data has to be cleared.
// If the json does not contain a name (the prototype would have no name), it means appending
// to the existing prototype (the parts are not cleared).
if( !vproto.parts.empty() && jo.has_string( "name" ) ) {
vproto = vehicle_prototype();
}
if( vproto.parts.empty() ) {
vproto.name = jo.get_string( "name" );
}
vgroups[vgroup_id(jo.get_string("id"))].add_vehicle(vproto_id(jo.get_string("id")), 100);
JsonArray parts = jo.get_array("parts");
while (parts.has_more()) {
JsonObject part = parts.next_object();
const point pxy( part.get_int("x"), part.get_int("y") );
const vpart_str_id pid( part.get_string( "part" ) );
vproto.parts.emplace_back( pxy, pid );
}
JsonArray items = jo.get_array("items");
while(items.has_more()) {
JsonObject spawn_info = items.next_object();
vehicle_item_spawn next_spawn;
next_spawn.pos.x = spawn_info.get_int("x");
next_spawn.pos.y = spawn_info.get_int("y");
next_spawn.chance = spawn_info.get_int("chance");
if(next_spawn.chance <= 0 || next_spawn.chance > 100) {
debugmsg("Invalid spawn chance in %s (%d, %d): %d%%",
vproto.name.c_str(), next_spawn.pos.x, next_spawn.pos.y, next_spawn.chance);
}
// constrain both with_magazine and with_ammo to [0-100]
next_spawn.with_magazine = std::max( std::min( spawn_info.get_int( "magazine", next_spawn.with_magazine ), 100 ), 0 );
next_spawn.with_ammo = std::max( std::min( spawn_info.get_int( "ammo", next_spawn.with_ammo ), 100 ), 0 );
if(spawn_info.has_array("items")) {
//Array of items that all spawn together (ie jack+tire)
JsonArray item_group = spawn_info.get_array("items");
while(item_group.has_more()) {
next_spawn.item_ids.push_back(item_group.next_string());
}
} else if(spawn_info.has_string("items")) {
//Treat single item as array
next_spawn.item_ids.push_back(spawn_info.get_string("items"));
}
if(spawn_info.has_array("item_groups")) {
//Pick from a group of items, just like map::place_items
JsonArray item_group_names = spawn_info.get_array("item_groups");
while(item_group_names.has_more()) {
next_spawn.item_groups.push_back(item_group_names.next_string());
}
} else if(spawn_info.has_string("item_groups")) {
next_spawn.item_groups.push_back(spawn_info.get_string("item_groups"));
}
vproto.item_spawns.push_back( std::move( next_spawn ) );
}
}
addiction get_next( JsonIn &jin ) const {
JsonObject jo = jin.get_object();
return addiction( addiction_type( jo.get_string( "type" ) ), jo.get_int( "intensity" ) );
}
void mutation_category_trait::load( JsonObject &jsobj )
{
mutation_category_trait new_category;
new_category.id = jsobj.get_string( "id" );
new_category.raw_name = jsobj.get_string( "name" );
new_category.threshold_mut = trait_id( jsobj.get_string( "threshold_mut" ) );
new_category.raw_mutagen_message = jsobj.get_string( "mutagen_message" );
new_category.mutagen_hunger = jsobj.get_int( "mutagen_hunger", 10 );
new_category.mutagen_thirst = jsobj.get_int( "mutagen_thirst", 10 );
new_category.mutagen_pain = jsobj.get_int( "mutagen_pain", 2 );
new_category.mutagen_fatigue = jsobj.get_int( "mutagen_fatigue", 5 );
new_category.mutagen_morale = jsobj.get_int( "mutagen_morale", 0 );
new_category.raw_iv_message = jsobj.get_string( "iv_message" );
new_category.iv_min_mutations = jsobj.get_int( "iv_min_mutations", 1 );
new_category.iv_additional_mutations = jsobj.get_int( "iv_additional_mutations", 2 );
new_category.iv_additional_mutations_chance = jsobj.get_int( "iv_additional_mutations_chance", 3 );
new_category.iv_hunger = jsobj.get_int( "iv_hunger", 10 );
new_category.iv_thirst = jsobj.get_int( "iv_thirst", 10 );
new_category.iv_pain = jsobj.get_int( "iv_pain", 2 );
new_category.iv_fatigue = jsobj.get_int( "iv_fatigue", 5 );
new_category.iv_morale = jsobj.get_int( "iv_morale", 0 );
new_category.iv_morale_max = jsobj.get_int( "iv_morale_max", 0 );
new_category.iv_sound = jsobj.get_bool( "iv_sound", false );
new_category.raw_iv_sound_message = jsobj.get_string( "iv_sound_message",
translate_marker( "You inject yoursel-arRGH!" ) );
new_category.raw_iv_sound_id = jsobj.get_string( "iv_sound_id", "shout" );
new_category.raw_iv_sound_variant = jsobj.get_string( "iv_sound_variant", "default" );
new_category.iv_noise = jsobj.get_int( "iv_noise", 0 );
new_category.iv_sleep = jsobj.get_bool( "iv_sleep", false );
new_category.raw_iv_sleep_message = jsobj.get_string( "iv_sleep_message",
translate_marker( "You fall asleep." ) );
new_category.iv_sleep_dur = jsobj.get_int( "iv_sleep_dur", 0 );
static_cast<void>( translate_marker_context( "memorial_male", "Crossed a threshold" ) );
static_cast<void>( translate_marker_context( "memorial_female", "Crossed a threshold" ) );
new_category.raw_memorial_message = jsobj.get_string( "memorial_message",
"Crossed a threshold" );
new_category.raw_junkie_message = jsobj.get_string( "junkie_message",
translate_marker( "Oh, yeah! That's the stuff!" ) );
mutation_category_traits[new_category.id] = new_category;
}
void load_construction(JsonObject &jo)
{
construction con;
con.id = constructions.size();
con.description = _(jo.get_string("description").c_str());
con.skill = skill_id( jo.get_string( "skill", skill_carpentry.str() ) );
con.difficulty = jo.get_int("difficulty");
con.category = jo.get_string("category", "OTHER");
// constructions use different time units in json, this makes it compatible
// with recipes/requirements, TODO: should be changed in json
con.time = jo.get_int("time") * 1000;
if( jo.has_string( "using" ) ) {
con.requirements = requirement_id( jo.get_string( "using" ) );
} else {
// Warning: the IDs may change!
std::string req_id = string_format( "inline_construction_%i", con.id );
requirement_data::load_requirement( jo, req_id );
con.requirements = requirement_id( req_id );
}
con.pre_terrain = jo.get_string("pre_terrain", "");
if (con.pre_terrain.size() > 1
&& con.pre_terrain[0] == 'f'
&& con.pre_terrain[1] == '_') {
con.pre_is_furniture = true;
} else {
con.pre_is_furniture = false;
}
con.post_terrain = jo.get_string("post_terrain", "");
if (con.post_terrain.size() > 1
&& con.post_terrain[0] == 'f'
&& con.post_terrain[1] == '_') {
con.post_is_furniture = true;
} else {
con.post_is_furniture = false;
}
con.pre_flags = jo.get_tags("pre_flags");
std::string prefunc = jo.get_string("pre_special", "");
if (prefunc == "check_empty") {
con.pre_special = &construct::check_empty;
} else if (prefunc == "check_support") {
con.pre_special = &construct::check_support;
} else if (prefunc == "check_deconstruct") {
con.pre_special = &construct::check_deconstruct;
} else if (prefunc == "check_up_OK") {
con.pre_special = &construct::check_up_OK;
} else if (prefunc == "check_down_OK") {
con.pre_special = &construct::check_down_OK;
} else {
if (prefunc != "") {
debugmsg("Unknown pre_special function: %s", prefunc.c_str());
}
con.pre_special = &construct::check_nothing;
}
std::string postfunc = jo.get_string("post_special", "");
if (postfunc == "done_tree") {
con.post_special = &construct::done_tree;
} else if (postfunc == "done_trunk_log") {
con.post_special = &construct::done_trunk_log;
} else if (postfunc == "done_trunk_plank") {
con.post_special = &construct::done_trunk_plank;
} else if (postfunc == "done_vehicle") {
con.post_special = &construct::done_vehicle;
} else if (postfunc == "done_deconstruct") {
con.post_special = &construct::done_deconstruct;
} else if (postfunc == "done_dig_stair") {
con.post_special = &construct::done_dig_stair;
} else if (postfunc == "done_mine_downstair") {
con.post_special = &construct::done_mine_downstair;
} else if (postfunc == "done_mine_upstair") {
con.post_special = &construct::done_mine_upstair;
} else if (postfunc == "done_window_curtains") {
con.post_special = &construct::done_window_curtains;
} else {
if (postfunc != "") {
debugmsg("Unknown post_special function: %s", postfunc.c_str());
}
con.post_special = &construct::done_nothing;
}
constructions.push_back(con);
}
void mod_manager::load_modfile(JsonObject &jo, const std::string &main_path)
{
if (!jo.has_string("type") || jo.get_string("type") != "MOD_INFO") {
// Ignore anything that is not a mod-info
return;
}
std::string m_ident = jo.get_string("ident");
if (has_mod(m_ident)) {
// TODO: change this to make unique ident for the mod
// (instead of discarding it?)
debugmsg("there is already a mod with ident %s", m_ident.c_str());
return;
}
std::string t_type = jo.get_string("mod-type", "SUPPLEMENTAL");
std::vector<std::string> m_authors;
if (jo.has_array("authors")) {
m_authors = jo.get_string_array("authors");
} else {
if(jo.has_string("author")) {
m_authors.push_back(jo.get_string("author"));
}
}
std::string m_name = jo.get_string("name", "");
if (m_name.empty()) {
// "No name" gets confusing if many mods have no name
//~ name of a mod that has no name entry, (%s is the mods identifier)
m_name = string_format(_("No name (%s)"), m_ident.c_str());
} else {
m_name = _(m_name.c_str());
}
std::string m_desc = jo.get_string("description", "");
if (m_desc.empty()) {
m_desc = _("No description");
} else {
m_desc = _(m_desc.c_str());
}
std::string m_path;
if (jo.has_string("path")) {
m_path = jo.get_string("path");
if (m_path.empty()) {
// If an empty path is given, use only the
// folder of the modinfo.json
m_path = main_path;
} else {
// prefix the folder of modinfo.json
m_path = main_path + "/" + m_path;
}
} else {
// Default if no path is given:
// "<folder-of-modinfo.json>/data"
m_path = main_path + "/data";
}
std::vector<std::string> m_dependencies;
if (jo.has_member("dependencies") && jo.has_array("dependencies")) {
JsonArray jarr = jo.get_array("dependencies");
while(jarr.has_more()) {
const std::string dep = jarr.next_string();
if (dep == m_ident) {
debugmsg("mod %s has itself as dependency", m_ident.c_str());
continue;
}
if (std::find(m_dependencies.begin(), m_dependencies.end(), dep) != m_dependencies.end()) {
// Some dependency listed twice, ignore it, what else can be done?
continue;
}
m_dependencies.push_back(dep);
}
}
mod_type m_type;
if (t_type == "CORE") {
m_type = MT_CORE;
} else if (t_type == "SUPPLEMENTAL") {
m_type = MT_SUPPLEMENTAL;
} else {
throw std::string("Invalid mod type: ") + t_type + " for mod " + m_ident;
}
MOD_INFORMATION *modfile = new MOD_INFORMATION;
modfile->ident = m_ident;
modfile->_type = m_type;
modfile->authors = m_authors;
modfile->name = m_name;
modfile->description = m_desc;
modfile->dependencies = m_dependencies;
modfile->path = m_path;
mod_map[modfile->ident] = modfile;
}
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 load_terrain(JsonObject &jsobj)
{
if ( terlist.empty() ) {
ter_t new_null = null_terrain_t();
termap[new_null.id] = new_null;
terlist.push_back(new_null);
}
ter_t new_terrain;
new_terrain.id = jsobj.get_string("id");
if ( new_terrain.id == "t_null" ) {
return;
}
new_terrain.name = _(jsobj.get_string("name").c_str());
//Special case for the LINE_ symbols
std::string symbol = jsobj.get_string("symbol");
if("LINE_XOXO" == symbol) {
new_terrain.sym = LINE_XOXO;
} else if("LINE_OXOX" == symbol) {
new_terrain.sym = LINE_OXOX;
} else {
new_terrain.sym = symbol.c_str()[0];
}
new_terrain.color = color_from_string(jsobj.get_string("color"));
new_terrain.movecost = jsobj.get_int("move_cost");
if(jsobj.has_member("trap")) {
// Store the string representation of the trap id.
// Overwrites the trap field in set_trap_ids() once ids are assigned..
new_terrain.trap_id_str = jsobj.get_string("trap");
}
new_terrain.trap = tr_null;
new_terrain.max_volume = jsobj.get_int("max_volume", MAX_VOLUME_IN_SQUARE);
new_terrain.transparent = false;
new_terrain.bitflags = 0;
JsonArray flags = jsobj.get_array("flags");
while(flags.has_more()) {
new_terrain.set_flag(flags.next_string());
}
if(jsobj.has_member("examine_action")) {
std::string function_name = jsobj.get_string("examine_action");
new_terrain.examine = iexamine_function_from_string(function_name);
} else {
// if not specified, default to no action
new_terrain.examine = iexamine_function_from_string("none");
}
// if the terrain has something harvestable
if (jsobj.has_member("harvestable")) {
new_terrain.harvestable = jsobj.get_string("harvestable"); // get the harvestable
new_terrain.transforms_into = jsobj.get_string("transforms_into"); // get the terrain to transform into later on
//get the harvest season
if (jsobj.get_string("harvest_season") == "SPRING") {new_terrain.harvest_season = 0;} // convert the season to int for calendar compare
else if (jsobj.get_string("harvest_season") == "SUMMER") {new_terrain.harvest_season = 1;}
else if (jsobj.get_string("harvest_season") == "AUTUMN") {new_terrain.harvest_season = 2;}
else {new_terrain.harvest_season = 3;}
}
new_terrain.open = "";
if ( jsobj.has_member("open") ) {
new_terrain.open = jsobj.get_string("open");
}
new_terrain.close = "";
if ( jsobj.has_member("close") ) {
new_terrain.close = jsobj.get_string("close");
}
new_terrain.bash.load(jsobj, "bash", false);
new_terrain.deconstruct.load(jsobj, "deconstruct", false);
new_terrain.loadid=terlist.size();
termap[new_terrain.id]=new_terrain;
terlist.push_back(new_terrain);
}
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 );
optional( jo, was_loaded, "attack_effs", atk_effs, mon_attack_effect_reader{} );
if( jo.has_member( "death_drops" ) ) {
JsonIn &stream = *jo.get_raw( "death_drops" );
death_drops = item_group::load_item_group( stream, "distribution" );
}
const typed_flag_reader<decltype( gen.death_map )> death_reader{ gen.death_map, "invalid monster death function" };
optional( jo, was_loaded, "death_function", dies, death_reader );
if( dies.empty() ) {
// TODO: really needed? Is an empty `dies` container not allowed?
dies.push_back( mdeath::normal );
}
if( jo.has_member( "special_when_hit" ) ) {
JsonArray jsarr = jo.get_array( "special_when_hit" );
const auto iter = gen.defense_map.find( jsarr.get_string( 0 ) );
if( iter == gen.defense_map.end() ) {
jsarr.throw_error( "Invalid monster defense function" );
}
sp_defense = iter->second;
def_chance = jsarr.get_int( 1 );
} else if( !was_loaded ) {
sp_defense = &mdefense::none;
def_chance = 0;
}
if( !was_loaded || jo.has_member( "special_attacks" ) ) {
special_attacks.clear();
special_attacks_names.clear();
add_special_attacks( jo, "special_attacks" );
} else {
// Note: special_attacks left as is, new attacks are added to it!
// Note: member name prefixes are compatible with those used by generic_typed_reader
remove_special_attacks( jo, "remove:special_attacks" );
add_special_attacks( jo, "add:special_attacks" );
}
// Disable upgrading when JSON contains `"upgrades": false`, but fallback to the
// normal behavior (including error checking) if "upgrades" is not boolean or not `false`.
if( jo.has_bool( "upgrades" ) && !jo.get_bool( "upgrades" ) ) {
upgrade_group = mongroup_id::NULL_ID;
upgrade_into = mtype_id::NULL_ID;
upgrades = false;
} else if( jo.has_member( "upgrades" ) ) {
JsonObject up = jo.get_object( "upgrades" );
optional( up, was_loaded, "half_life", half_life, -1 );
optional( up, was_loaded, "into_group", upgrade_group, auto_flags_reader<mongroup_id> {}, mongroup_id::NULL_ID );
optional( up, was_loaded, "into", upgrade_into, auto_flags_reader<mtype_id> {}, mtype_id::NULL_ID );
upgrades = true;
}
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 );
}
/**
* Reads in a vehicle part from a JsonObject.
*/
void game::load_vehiclepart(JsonObject &jo)
{
vpart_info next_part;
next_part.id = jo.get_string("id");
next_part.name = _(jo.get_string("name").c_str());
next_part.sym = jo.get_string("symbol")[0];
next_part.color = color_from_string(jo.get_string("color"));
next_part.sym_broken = jo.get_string("broken_symbol")[0];
next_part.color_broken = color_from_string(jo.get_string("broken_color"));
next_part.dmg_mod = jo.has_member("damage_modifier") ? jo.get_int("damage_modifier") : 100;
next_part.durability = jo.get_int("durability");
if(jo.has_member("power")) {
next_part.power = jo.get_int("power");
} else { //defaults to 0
next_part.power = 0;
}
//Handle the par1 union as best we can by accepting any ONE of its elements
int element_count = (jo.has_member("par1") ? 1 : 0)
+ (jo.has_member("size") ? 1 : 0)
+ (jo.has_member("wheel_width") ? 1 : 0)
+ (jo.has_member("bonus") ? 1 : 0);
if(element_count == 0) {
//If not specified, assume 0
next_part.par1 = 0;
} else if(element_count == 1) {
if(jo.has_member("par1")) {
next_part.par1 = jo.get_int("par1");
} else if(jo.has_member("size")) {
next_part.par1 = jo.get_int("size");
} else if(jo.has_member("wheel_width")) {
next_part.par1 = jo.get_int("wheel_width");
} else { //bonus
next_part.par1 = jo.get_int("bonus");
}
} else {
//Too many
debugmsg("Error parsing vehicle part '%s': \
Use AT MOST one of: par1, power, size, wheel_width, bonus",
next_part.name.c_str());
//Keep going to produce more messages if other parts are wrong
next_part.par1 = 0;
}
next_part.fuel_type = jo.has_member("fuel_type") ? jo.get_string("fuel_type") : "NULL";
next_part.item = jo.get_string("item");
next_part.difficulty = jo.get_int("difficulty");
next_part.location = jo.has_member("location") ? jo.get_string("location") : "";
JsonArray jarr = jo.get_array("flags");
while (jarr.has_more()){
next_part.flags.insert(jarr.next_string());
}
//Plating shouldn't actually be shown; another part will be.
//Calculate and cache z-ordering based off of location
if(next_part.has_flag("ARMOR")) {
next_part.z_order = -2;
} else if(next_part.location == "on_roof") {
next_part.z_order = 8;
} else if(next_part.location == "center") {
next_part.z_order = 7;
} else if(next_part.location == "under") {
//Have wheels show up over frames
next_part.z_order = 6;
} else if(next_part.location == "structure") {
next_part.z_order = 5;
} else if(next_part.location == "engine_block") {
//Should be hidden by frames
next_part.z_order = 4;
} else if(next_part.location == "fuel_source") {
//Should be hidden by frames
next_part.z_order = 3;
} else if(next_part.location == "roof") {
//Shouldn't be displayed
next_part.z_order = -1;
} else {
//Everything else
next_part.z_order = 0;
}
vehicle_part_types[next_part.id] = next_part;
}
void mtype::load( JsonObject &jo, const std::string &src )
{
bool strict = src == "dda";
MonsterGenerator &gen = MonsterGenerator::generator();
// Name and name plural are not translated here, but when needed in
// combination with the actual count in `mtype::nname`.
mandatory( jo, was_loaded, "name", name );
// default behaviour: Assume the regular plural form (appending an “s”)
optional( jo, was_loaded, "name_plural", name_plural, name + "s" );
optional( jo, was_loaded, "description", description );
optional( jo, was_loaded, "material", mat, auto_flags_reader<material_id> {} );
optional( jo, was_loaded, "species", species, auto_flags_reader<species_id> {} );
optional( jo, was_loaded, "categories", categories, auto_flags_reader<> {} );
// See monfaction.cpp
if( !was_loaded || jo.has_member( "default_faction" ) ) {
const auto faction = mfaction_str_id( jo.get_string( "default_faction" ) );
default_faction = monfactions::get_or_add_faction( faction );
}
if( !was_loaded || jo.has_member( "symbol" ) ) {
sym = jo.get_string( "symbol" );
if( utf8_wrapper( sym ).display_width() != 1 ) {
jo.throw_error( "monster symbol should be exactly one console cell width", "symbol" );
}
}
assign( jo, "color", color );
const typed_flag_reader<decltype( Creature::size_map )> size_reader{ Creature::size_map, "invalid creature size" };
optional( jo, was_loaded, "size", size, size_reader, MS_MEDIUM );
const typed_flag_reader<decltype( gen.phase_map )> phase_reader{ gen.phase_map, "invalid phase id" };
optional( jo, was_loaded, "phase", phase, phase_reader, SOLID );
assign( jo, "diff", difficulty, strict, 0 );
assign( jo, "hp", hp, strict, 1 );
assign( jo, "speed", speed, strict, 0 );
assign( jo, "aggression", agro, strict, -100, 100 );
assign( jo, "morale", morale, strict );
assign( jo, "attack_cost", attack_cost, strict, 0 );
assign( jo, "melee_skill", melee_skill, strict, 0 );
assign( jo, "melee_dice", melee_dice, strict, 0 );
assign( jo, "melee_dice_sides", melee_sides, strict, 0 );
assign( jo, "dodge", sk_dodge, strict, 0 );
assign( jo, "armor_bash", armor_bash, strict, 0 );
assign( jo, "armor_cut", armor_cut, strict, 0 );
assign( jo, "armor_stab", armor_stab, strict, 0 );
assign( jo, "armor_acid", armor_acid, strict, 0 );
assign( jo, "armor_fire", armor_fire, strict, 0 );
assign( jo, "vision_day", vision_day, strict, 0 );
assign( jo, "vision_night", vision_night, strict, 0 );
optional( jo, was_loaded, "starting_ammo", starting_ammo );
optional( jo, was_loaded, "luminance", luminance, 0 );
optional( jo, was_loaded, "revert_to_itype", revert_to_itype, "" );
optional( jo, was_loaded, "attack_effs", atk_effs, mon_attack_effect_reader{} );
// TODO: make this work with `was_loaded`
if( jo.has_array( "melee_damage" ) ) {
JsonArray arr = jo.get_array( "melee_damage" );
melee_damage = load_damage_instance( arr );
} else if( jo.has_object( "melee_damage" ) ) {
melee_damage = load_damage_instance( jo );
}
if( jo.has_int( "melee_cut" ) ) {
int bonus_cut = jo.get_int( "melee_cut" );
melee_damage.add_damage( DT_CUT, bonus_cut );
}
if( jo.has_member( "death_drops" ) ) {
JsonIn &stream = *jo.get_raw( "death_drops" );
death_drops = item_group::load_item_group( stream, "distribution" );
}
assign( jo, "harvest", harvest, strict );
const typed_flag_reader<decltype( gen.death_map )> death_reader{ gen.death_map, "invalid monster death function" };
optional( jo, was_loaded, "death_function", dies, death_reader );
if( dies.empty() ) {
// TODO: really needed? Is an empty `dies` container not allowed?
dies.push_back( mdeath::normal );
}
assign( jo, "emit_fields", emit_fields );
if( jo.has_member( "special_when_hit" ) ) {
JsonArray jsarr = jo.get_array( "special_when_hit" );
const auto iter = gen.defense_map.find( jsarr.get_string( 0 ) );
if( iter == gen.defense_map.end() ) {
jsarr.throw_error( "Invalid monster defense function" );
}
sp_defense = iter->second;
def_chance = jsarr.get_int( 1 );
} else if( !was_loaded ) {
sp_defense = &mdefense::none;
def_chance = 0;
}
if( !was_loaded || jo.has_member( "special_attacks" ) ) {
special_attacks.clear();
special_attacks_names.clear();
add_special_attacks( jo, "special_attacks", src );
} else {
// Note: special_attacks left as is, new attacks are added to it!
// Note: member name prefixes are compatible with those used by generic_typed_reader
if( jo.has_object( "extend" ) ) {
auto tmp = jo.get_object( "extend" );
add_special_attacks( tmp, "special_attacks", src );
}
if( jo.has_object( "delete" ) ) {
auto tmp = jo.get_object( "delete" );
remove_special_attacks( tmp, "special_attacks", src );
}
}
// Disable upgrading when JSON contains `"upgrades": false`, but fallback to the
// normal behavior (including error checking) if "upgrades" is not boolean or not `false`.
if( jo.has_bool( "upgrades" ) && !jo.get_bool( "upgrades" ) ) {
upgrade_group = mongroup_id::NULL_ID();
upgrade_into = mtype_id::NULL_ID();
upgrades = false;
} else if( jo.has_member( "upgrades" ) ) {
JsonObject up = jo.get_object( "upgrades" );
optional( up, was_loaded, "half_life", half_life, -1 );
optional( up, was_loaded, "into_group", upgrade_group, auto_flags_reader<mongroup_id> {},
mongroup_id::NULL_ID() );
optional( up, was_loaded, "into", upgrade_into, auto_flags_reader<mtype_id> {},
mtype_id::NULL_ID() );
upgrades = true;
}
optional( jo, was_loaded, "burn_into", burn_into, auto_flags_reader<mtype_id> {},
mtype_id::NULL_ID() );
const typed_flag_reader<decltype( gen.flag_map )> flag_reader{ gen.flag_map, "invalid monster flag" };
optional( jo, was_loaded, "flags", flags, flag_reader );
// Can't calculate yet - we want all flags first
optional( jo, was_loaded, "bash_skill", bash_skill, -1 );
const typed_flag_reader<decltype( gen.trigger_map )> trigger_reader{ gen.trigger_map, "invalid monster trigger" };
optional( jo, was_loaded, "anger_triggers", anger, trigger_reader );
optional( jo, was_loaded, "placate_triggers", placate, trigger_reader );
optional( jo, was_loaded, "fear_triggers", fear, trigger_reader );
if( jo.has_member( "path_settings" ) ) {
auto jop = jo.get_object( "path_settings" );
// Here rather than in pathfinding.cpp because we want monster-specific defaults and was_loaded
optional( jop, was_loaded, "max_dist", path_settings.max_dist, 0 );
optional( jop, was_loaded, "max_length", path_settings.max_length, -1 );
optional( jop, was_loaded, "bash_strength", path_settings.bash_strength, -1 );
optional( jop, was_loaded, "allow_open_doors", path_settings.allow_open_doors, false );
optional( jop, was_loaded, "avoid_traps", path_settings.avoid_traps, false );
optional( jop, was_loaded, "allow_climb_stairs", path_settings.allow_climb_stairs, true );
}
}
void load_construction(JsonObject &jo)
{
construction *con = new construction;
JsonArray temp;
con->description = _(jo.get_string("description").c_str());
con->skill = _(jo.get_string("skill", "carpentry").c_str());
con->difficulty = jo.get_int("difficulty");
con->time = jo.get_int("time");
temp = jo.get_array("tools");
while (temp.has_more()) {
std::vector<component> tool_choices;
JsonArray ja = temp.next_array();
while (ja.has_more()) {
std::string name = ja.next_string();
tool_choices.push_back(component(name, 1));
}
con->tools.push_back(tool_choices);
}
temp = jo.get_array("components");
while (temp.has_more()) {
std::vector<component> comp_choices;
JsonArray ja = temp.next_array();
while (ja.has_more()) {
JsonArray comp = ja.next_array();
std::string name = comp.get_string(0);
int quant = comp.get_int(1);
comp_choices.push_back(component(name, quant));
}
con->components.push_back(comp_choices);
}
con->pre_terrain = jo.get_string("pre_terrain", "");
if (con->pre_terrain.size() > 1
&& con->pre_terrain[0] == 'f'
&& con->pre_terrain[1] == '_') {
con->pre_is_furniture = true;
} else {
con->pre_is_furniture = false;
}
con->post_terrain = jo.get_string("post_terrain", "");
if (con->post_terrain.size() > 1
&& con->post_terrain[0] == 'f'
&& con->post_terrain[1] == '_') {
con->post_is_furniture = true;
} else {
con->post_is_furniture = false;
}
con->pre_flags = jo.get_tags("pre_flags");
std::string prefunc = jo.get_string("pre_special", "");
if (prefunc == "check_empty") {
con->pre_special = &construct::check_empty;
} else if (prefunc == "check_support") {
con->pre_special = &construct::check_support;
} else {
// should probably print warning if not ""
con->pre_special = &construct::check_nothing;
}
std::string postfunc = jo.get_string("post_special", "");
if (postfunc == "done_tree") {
con->post_special = &construct::done_tree;
} else if (postfunc == "done_trunk_log") {
con->post_special = &construct::done_trunk_log;
} else if (postfunc == "done_trunk_plank") {
con->post_special = &construct::done_trunk_plank;
} else if (postfunc == "done_vehicle") {
con->post_special = &construct::done_vehicle;
} else if (postfunc == "done_deconstruct") {
con->post_special = &construct::done_deconstruct;
} else {
// ditto, should probably warn here
con->post_special = &construct::done_nothing;
}
con->id = constructions.size();
constructions.push_back(con);
}
void recipe::load( JsonObject &jo, const std::string &src )
{
bool strict = src == "dda";
abstract = jo.has_string( "abstract" );
if( abstract ) {
ident_ = recipe_id( jo.get_string( "abstract" ) );
} else {
result_ = jo.get_string( "result" );
ident_ = recipe_id( result_ );
}
if( jo.has_bool( "obsolete" ) ) {
assign( jo, "obsolete", obsolete );
}
assign( jo, "time", time, strict, 0 );
assign( jo, "difficulty", difficulty, strict, 0, MAX_SKILL );
assign( jo, "flags", flags );
// automatically set contained if we specify as container
assign( jo, "contained", contained, strict );
contained |= assign( jo, "container", container, strict );
if( jo.has_array( "batch_time_factors" ) ) {
auto batch = jo.get_array( "batch_time_factors" );
batch_rscale = batch.get_int( 0 ) / 100.0;
batch_rsize = batch.get_int( 1 );
}
assign( jo, "charges", charges );
assign( jo, "result_mult", result_mult );
assign( jo, "skill_used", skill_used, strict );
if( jo.has_member( "skills_required" ) ) {
auto sk = jo.get_array( "skills_required" );
required_skills.clear();
if( sk.empty() ) {
// clear all requirements
} else if( sk.has_array( 0 ) ) {
// multiple requirements
while( sk.has_more() ) {
auto arr = sk.next_array();
required_skills[skill_id( arr.get_string( 0 ) )] = arr.get_int( 1 );
}
} else {
// single requirement
required_skills[skill_id( sk.get_string( 0 ) )] = sk.get_int( 1 );
}
}
// simplified autolearn sets requirements equal to required skills at finalization
if( jo.has_bool( "autolearn" ) ) {
assign( jo, "autolearn", autolearn );
} else if( jo.has_array( "autolearn" ) ) {
autolearn = true;
auto sk = jo.get_array( "autolearn" );
while( sk.has_more() ) {
auto arr = sk.next_array();
autolearn_requirements[skill_id( arr.get_string( 0 ) )] = arr.get_int( 1 );
}
}
// Never let the player have a debug or NPC recipe
if( jo.has_bool( "never_learn" ) ) {
assign( jo, "never_learn", never_learn );
}
if( jo.has_member( "decomp_learn" ) ) {
learn_by_disassembly.clear();
if( jo.has_int( "decomp_learn" ) ) {
if( !skill_used ) {
jo.throw_error( "decomp_learn specified with no skill_used" );
}
assign( jo, "decomp_learn", learn_by_disassembly[skill_used] );
} else if( jo.has_array( "decomp_learn" ) ) {
auto sk = jo.get_array( "decomp_learn" );
while( sk.has_more() ) {
auto arr = sk.next_array();
learn_by_disassembly[skill_id( arr.get_string( 0 ) )] = arr.get_int( 1 );
}
}
}
if( jo.has_member( "book_learn" ) ) {
auto bk = jo.get_array( "book_learn" );
booksets.clear();
while( bk.has_more() ) {
auto arr = bk.next_array();
booksets.emplace( arr.get_string( 0 ), arr.size() > 1 ? arr.get_int( 1 ) : -1 );
}
}
// recipes not specifying any external requirements inherit from their parent recipe (if any)
if( jo.has_string( "using" ) ) {
reqs_external = { { requirement_id( jo.get_string( "using" ) ), 1 } };
} else if( jo.has_array( "using" ) ) {
auto arr = jo.get_array( "using" );
reqs_external.clear();
while( arr.has_more() ) {
auto cur = arr.next_array();
reqs_external.emplace_back( requirement_id( cur.get_string( 0 ) ), cur.get_int( 1 ) );
}
}
const std::string type = jo.get_string( "type" );
if( type == "recipe" ) {
if( jo.has_string( "id_suffix" ) ) {
if( abstract ) {
jo.throw_error( "abstract recipe cannot specify id_suffix", "id_suffix" );
}
ident_ = recipe_id( ident_.str() + "_" + jo.get_string( "id_suffix" ) );
}
assign( jo, "category", category, strict );
assign( jo, "subcategory", subcategory, strict );
assign( jo, "description", description, strict );
assign( jo, "reversible", reversible, strict );
if( jo.has_member( "byproducts" ) ) {
if( this->reversible ) {
jo.throw_error( "Recipe cannot be reversible and have byproducts" );
}
auto bp = jo.get_array( "byproducts" );
byproducts.clear();
while( bp.has_more() ) {
auto arr = bp.next_array();
byproducts[ arr.get_string( 0 ) ] += arr.size() == 2 ? arr.get_int( 1 ) : 1;
}
}
} else if( type == "uncraft" ) {
reversible = true;
} else {
jo.throw_error( "unknown recipe type", "type" );
}
assign( jo, "construction_blueprint", blueprint );
// inline requirements are always replaced (cannot be inherited)
const requirement_id req_id( string_format( "inline_%s_%s", type.c_str(), ident_.c_str() ) );
requirement_data::load_requirement( jo, req_id );
reqs_internal = { { req_id, 1 } };
}
/**
* Reads in a vehicle part from a JsonObject.
*/
void vpart_info::load( JsonObject &jo )
{
vpart_info next_part;
next_part.id = vpart_str_id( jo.get_string( "id" ) );
next_part.name = _(jo.get_string("name").c_str());
next_part.sym = jo.get_string("symbol")[0];
next_part.color = color_from_string(jo.get_string("color"));
next_part.sym_broken = jo.get_string("broken_symbol")[0];
next_part.color_broken = color_from_string(jo.get_string("broken_color"));
next_part.dmg_mod = jo.has_member("damage_modifier") ? jo.get_int("damage_modifier") : 100;
next_part.durability = jo.get_int("durability");
next_part.power = jo.get_int("power", 0);
next_part.epower = jo.get_int("epower", 0);
next_part.folded_volume = jo.get_int("folded_volume", 0);
next_part.range = jo.get_int( "range", 12 );
next_part.size = jo.get_int( "size", 0 );
//Handle the par1 union as best we can by accepting any ONE of its elements
int element_count = (jo.has_member("par1") ? 1 : 0)
+ (jo.has_member("wheel_width") ? 1 : 0)
+ (jo.has_member("bonus") ? 1 : 0);
if(element_count == 0) {
//If not specified, assume 0
next_part.par1 = 0;
} else if(element_count == 1) {
if(jo.has_member("par1")) {
next_part.par1 = jo.get_int("par1");
} else if(jo.has_member("wheel_width")) {
next_part.par1 = jo.get_int("wheel_width");
} else { //bonus
next_part.par1 = jo.get_int("bonus");
}
} else {
//Too many
debugmsg("Error parsing vehicle part '%s': \
Use AT MOST one of: par1, wheel_width, bonus",
next_part.name.c_str());
//Keep going to produce more messages if other parts are wrong
next_part.par1 = 0;
}
next_part.fuel_type = jo.get_string( "fuel_type", "null" );
next_part.item = jo.get_string("item");
next_part.difficulty = jo.get_int("difficulty");
next_part.location = jo.has_member("location") ? jo.get_string("location") : "";
JsonArray jarr = jo.get_array("flags");
while (jarr.has_more()) {
next_part.set_flag( jarr.next_string() );
}
if( jo.has_member( "breaks_into" ) ) {
JsonIn& stream = *jo.get_raw( "breaks_into" );
next_part.breaks_into_group = item_group::load_item_group( stream, "collection" );
} else {
next_part.breaks_into_group = "EMPTY_GROUP";
}
//Calculate and cache z-ordering based off of location
// list_order is used when inspecting the vehicle
if(next_part.location == "on_roof") {
next_part.z_order = 9;
next_part.list_order = 3;
} else if(next_part.location == "on_cargo") {
next_part.z_order = 8;
next_part.list_order = 6;
} else if(next_part.location == "center") {
next_part.z_order = 7;
next_part.list_order = 7;
} else if(next_part.location == "under") {
//Have wheels show up over frames
next_part.z_order = 6;
next_part.list_order = 10;
} else if(next_part.location == "structure") {
next_part.z_order = 5;
next_part.list_order = 1;
} else if(next_part.location == "engine_block") {
//Should be hidden by frames
next_part.z_order = 4;
next_part.list_order = 8 ;
} else if (next_part.location == "on_battery_mount"){
//Should be hidden by frames
next_part.z_order = 3;
next_part.list_order = 10;
} else if(next_part.location == "fuel_source") {
//Should be hidden by frames
next_part.z_order = 3;
next_part.list_order = 9;
} else if(next_part.location == "roof") {
//Shouldn't be displayed
next_part.z_order = -1;
next_part.list_order = 4;
} else if(next_part.location == "armor") {
//Shouldn't be displayed (the color is used, but not the symbol)
next_part.z_order = -2;
next_part.list_order = 2;
} else {
//Everything else
next_part.z_order = 0;
next_part.list_order = 5;
}
auto const iter = vehicle_part_types.find( next_part.id );
if( iter != vehicle_part_types.end() ) {
// Entry in the map already exists, so the pointer in the vector is already correct
// and does not need to be changed, only the int-id needs to be taken from the old entry.
next_part.loadid = iter->second.loadid;
iter->second = next_part;
} else {
// The entry is new, "generate" a new int-id and link the new entry from the vector.
next_part.loadid = vpart_id( vehicle_part_int_types.size() );
vpart_info &new_entry = vehicle_part_types[next_part.id];
new_entry = next_part;
vehicle_part_int_types.push_back( &new_entry );
}
}
std::pair<skill_id, int> get_next( JsonIn &jin ) const {
JsonObject jo = jin.get_object();
return std::pair<skill_id, int>( skill_id( jo.get_string( "name" ) ), jo.get_int( "level" ) );
}
ma_buff load_buff(JsonObject &jo)
{
ma_buff buff;
buff.id = jo.get_string("id");
buff.name = _(jo.get_string("name").c_str());
buff.description = _(jo.get_string("description").c_str());
buff.buff_duration = jo.get_int("buff_duration", 2);
buff.max_stacks = jo.get_int("max_stacks", 1);
buff.reqs.unarmed_allowed = jo.get_bool("unarmed_allowed", false);
buff.reqs.melee_allowed = jo.get_bool("melee_allowed", false);
buff.reqs.min_melee = jo.get_int("min_melee", 0);
buff.reqs.min_unarmed = jo.get_int("min_unarmed", 0);
buff.dodges_bonus = jo.get_int("bonus_dodges", 0);
buff.blocks_bonus = jo.get_int("bonus_blocks", 0);
buff.hit = jo.get_int("hit", 0);
buff.bash = jo.get_int("bash", 0);
buff.cut = jo.get_int("cut", 0);
buff.dodge = jo.get_int("dodge", 0);
buff.speed = jo.get_int("speed", 0);
buff.block = jo.get_int("block", 0);
buff.arm_bash = jo.get_int("arm_bash", 0);
buff.arm_cut = jo.get_int("arm_cut", 0);
buff.bash_stat_mult = jo.get_float("bash_mult", 1.0);
buff.cut_stat_mult = jo.get_float("cut_mult", 1.0);
buff.hit_str = jo.get_float("hit_str", 0.0);
buff.hit_dex = jo.get_float("hit_dex", 0.0);
buff.hit_int = jo.get_float("hit_int", 0.0);
buff.hit_per = jo.get_float("hit_per", 0.0);
buff.bash_str = jo.get_float("bash_str", 0.0);
buff.bash_dex = jo.get_float("bash_dex", 0.0);
buff.bash_int = jo.get_float("bash_int", 0.0);
buff.bash_per = jo.get_float("bash_per", 0.0);
buff.cut_str = jo.get_float("cut_str", 0.0);
buff.cut_dex = jo.get_float("cut_dex", 0.0);
buff.cut_int = jo.get_float("cut_int", 0.0);
buff.cut_per = jo.get_float("cut_per", 0.0);
buff.dodge_str = jo.get_float("dodge_str", 0.0);
buff.dodge_dex = jo.get_float("dodge_dex", 0.0);
buff.dodge_int = jo.get_float("dodge_int", 0.0);
buff.dodge_per = jo.get_float("dodge_per", 0.0);
buff.block_str = jo.get_float("block_str", 0.0);
buff.block_dex = jo.get_float("block_dex", 0.0);
buff.block_int = jo.get_float("block_int", 0.0);
buff.block_per = jo.get_float("block_per", 0.0);
buff.quiet = jo.get_bool("quiet", false);
buff.throw_immune = jo.get_bool("throw_immune", false);
buff.reqs.req_buffs = jo.get_tags("req_buffs");
ma_buffs[buff.id] = buff;
return buff;
}
void Item_factory::load_basic_info(JsonObject& jo, itype* new_item_template)
{
std::string new_id = jo.get_string("id");
new_item_template->id = new_id;
if(m_templates.count(new_id) > 0) {
// New item already exists. Because mods are loaded after
// core data, we override it. This allows mods to change
// item from core data.
delete m_templates[new_id];
}
m_templates[new_id] = new_item_template;
itypes[new_id] = new_item_template;
standard_itype_ids.push_back(new_id);
// And then proceed to assign the correct field
new_item_template->price = jo.get_int("price");
new_item_template->name = _(jo.get_string("name").c_str());
new_item_template->sym = jo.get_string("symbol")[0];
new_item_template->color = color_from_string(jo.get_string("color"));
new_item_template->description = _(jo.get_string("description").c_str());
if(jo.has_member("material")){
set_material_from_json(jo, "material", new_item_template);
} else {
new_item_template->m1 = "null";
new_item_template->m2 = "null";
}
Item_tag new_phase = "solid";
if(jo.has_member("phase")){
new_phase = jo.get_string("phase");
}
new_item_template->phase = phase_from_tag(new_phase);
new_item_template->volume = jo.get_int("volume");
new_item_template->weight = jo.get_int("weight");
new_item_template->melee_dam = jo.get_int("bashing");
new_item_template->melee_cut = jo.get_int("cutting");
new_item_template->m_to_hit = jo.get_int("to_hit");
new_item_template->light_emission = 0;
/*
List of current flags
FIT - Reduces encumbrance by one
SKINTIGHT - Reduces layer penalty
VARSIZE - Can be made to fit via tailoring
OVERSIZE - Can always be worn no matter encumbrance/mutations/bionics/etc
POCKETS - Will increase warmth for hands if hands are cold and the player is wielding nothing
HOOD - Will increase warmth for head if head is cold and player's head isn't encumbered
RAINPROOF - Works like a raincoat to protect from rain effects
WATCH - Shows the current time, instead of sun/moon position
ALARMCLOCK - Has an alarmclock feature
FANCY - Less than practical clothing meant primarily to convey a certain image.
SUPER_FANCY - Clothing suitable for the most posh of events.
LIGHT_* - light emission, sets cached int light_emission
USE_EAT_VERB - Use the eat verb, even if it's a liquid(soup, jam etc.)
STURDY - Clothing is made to be armor. Prevents damage to armor unless it is penetrated.
SWIM_GOGGLES - Allows you to see much further under water.
REBREATHER - Works with an active UPS to supply you with oxygen while underwater.
Container-only flags:
SEALS
RIGID
WATERTIGHT
*/
new_item_template->item_tags = jo.get_tags("flags");
if ( new_item_template->item_tags.size() > 0 ) {
for( std::set<std::string>::const_iterator it = new_item_template->item_tags.begin();
it != new_item_template->item_tags.end(); ++it ) {
set_intvar(std::string(*it), new_item_template->light_emission, 1, 10000);
}
}
if( jo.has_member("qualities") ){
set_qualities_from_json(jo, "qualities", new_item_template);
}
new_item_template->techniques = jo.get_tags("techniques");
new_item_template->use = (!jo.has_member("use_action") ? &iuse::none :
use_from_string(jo.get_string("use_action")));
if(jo.has_member("category")) {
new_item_template->category = get_category(jo.get_string("category"));
} else {
new_item_template->category = get_category(calc_category(new_item_template));
}
}
