bool read_from_file_json( const std::string &path, const std::function<void( JsonIn & )> &reader )
{
return read_from_file( path, [&reader]( std::istream & fin ) {
JsonIn jsin( fin );
reader( jsin );
} );
}
void auto_pickup::load(const bool bCharacter)
{
bChar = bCharacter;
std::ifstream fin;
std::string sFile = FILENAMES["autopickup"];
if (bCharacter) {
sFile = world_generator->active_world->world_path + "/" + base64_encode(g->u.name) + ".apu.json";
}
fin.open(sFile.c_str(), std::ifstream::in | std::ifstream::binary);
if( !fin.good() ) {
if (load_legacy(bCharacter)) {
if (save(bCharacter)) {
remove_file(sFile);
}
}
} else {
try {
JsonIn jsin(fin);
deserialize(jsin);
} catch( const JsonError &e ) {
DebugLog(D_ERROR, DC_ALL) << "auto_pickup::load: " << e;
}
}
fin.close();
}
void load_names_from_file( const std::string &filename )
{
std::ifstream data_file;
data_file.open( filename.c_str(), std::ifstream::in | std::ifstream::binary );
if( !data_file.good() ) {
throw std::runtime_error( std::string( "Could not read " ) + filename );
}
NameGenerator &gen = NameGenerator::generator();
std::istringstream iss(
std::string(
( std::istreambuf_iterator<char>( data_file ) ),
std::istreambuf_iterator<char>()
)
);
JsonIn jsin( iss );
data_file.close();
// load em all
jsin.start_array();
while( !jsin.end_array() ) {
JsonObject json_name = jsin.get_object();
gen.load_name( json_name );
}
}
static void load_obsolete_mods( const std::string path )
{
// info_file_path is the fully qualified path to the information file for this mod
std::ifstream infile( path.c_str(), std::ifstream::in | std::ifstream::binary );
if( !infile ) {
// fail silently?
return;
}
try {
JsonIn jsin( infile );
jsin.eat_whitespace();
char ch = jsin.peek();
if( ch == '[' ) {
jsin.start_array();
// find type and dispatch each object until array close
while (!jsin.end_array()) {
obsolete_mod_list.insert( jsin.get_string() );
}
} else {
// not an object or an array?
std::stringstream err;
err << jsin.line_number() << ": ";
err << "expected array, but found '" << ch << "'";
throw err.str();
}
} catch(std::string e) {
debugmsg("%s", e.c_str());
}
}
void load_json_dir(std::string const &dirname)
{
// get a list of all files in the directory
std::vector<std::string> dir =
get_files_from_path(".json", dirname, true, true);
// iterate over each file
std::vector<std::string>::iterator it;
for (it = dir.begin(); it != dir.end(); it++) {
// open the file as a stream
std::ifstream infile(it->c_str(), std::ifstream::in | std::ifstream::binary);
// and stuff it into ram
std::istringstream iss(
std::string(
(std::istreambuf_iterator<char>(infile)),
std::istreambuf_iterator<char>()
)
);
infile.close();
// parse it
try {
JsonIn jsin(iss);
load_all_from_json(jsin);
} catch( const JsonError &err ) {
throw std::runtime_error( *(it) + ": " + err.what() );
}
}
}
void mod_manager::load_mods_list(WORLDPTR world) const
{
if (world == NULL) {
return;
}
std::vector<std::string> &amo = world->active_mod_order;
amo.clear();
std::ifstream mods_list_file(get_mods_list_file(world).c_str(), std::ios::in | std::ios::binary);
if (!mods_list_file) {
return;
}
try {
JsonIn jsin(mods_list_file);
JsonArray ja = jsin.get_array();
while (ja.has_more()) {
const std::string mod = ja.next_string();
if (mod.empty() || std::find(amo.begin(), amo.end(), mod) != amo.end()) {
continue;
}
amo.push_back(mod);
}
} catch (std::string e) {
DebugLog( D_ERROR, DC_ALL ) << "worldfactory: loading mods list failed: " << e;
}
}
void DynamicDataLoader::load_deferred( deferred_json &data )
{
while( !data.empty() ) {
const size_t n = data.size();
auto it = data.begin();
for( size_t idx = 0; idx != n; ++idx ) {
try {
std::istringstream str( it->first );
JsonIn jsin( str );
JsonObject jo = jsin.get_object();
load_object( jo, it->second );
} catch( const std::exception &err ) {
debugmsg( "Error loading data from json: %s", err.what() );
}
++it;
}
data.erase( data.begin(), it );
if( data.size() == n ) {
std::ostringstream discarded;
for( const auto &elem : data ) {
discarded << elem.first;
}
debugmsg( "JSON contains circular dependency. Discarded %i objects:\n%s",
data.size(), discarded.str().c_str() );
data.clear();
return; // made no progress on this cycle so abort
}
}
}
int curses_start_color(void)
{
colorpairs = new pairs[100];
//Load the console colors from colors.json
std::ifstream colorfile("data/raw/colors.json", std::ifstream::in | std::ifstream::binary);
try{
JsonIn jsin(colorfile);
char ch;
// Manually load the colordef object because the json handler isn't loaded yet.
jsin.eat_whitespace();
ch = jsin.peek();
if( ch == '[' ) {
jsin.start_array();
// find type and dispatch each object until array close
while (!jsin.end_array()) {
jsin.eat_whitespace();
char ch = jsin.peek();
if (ch != '{') {
std::stringstream err;
err << jsin.line_number() << ": ";
err << "expected array of objects but found '";
err << ch << "', not '{'";
throw err.str();
}
JsonObject jo = jsin.get_object();
load_colors(jo);
jo.finish();
}
} else {
// not an array?
std::stringstream err;
err << jsin.line_number() << ": ";
err << "expected object or array, but found '" << ch << "'";
throw err.str();
}
}
catch(std::string e){
throw "data/raw/colors.json: " + e;
}
if(consolecolors.empty())return 0;
windowsPalette[0] = BGR(ccolor("BLACK"));
windowsPalette[1] = BGR(ccolor("RED"));
windowsPalette[2] = BGR(ccolor("GREEN"));
windowsPalette[3] = BGR(ccolor("BROWN"));
windowsPalette[4] = BGR(ccolor("BLUE"));
windowsPalette[5] = BGR(ccolor("MAGENTA"));
windowsPalette[6] = BGR(ccolor("CYAN"));
windowsPalette[7] = BGR(ccolor("GRAY"));
windowsPalette[8] = BGR(ccolor("DGRAY"));
windowsPalette[9] = BGR(ccolor("LRED"));
windowsPalette[10] = BGR(ccolor("LGREEN"));
windowsPalette[11] = BGR(ccolor("YELLOW"));
windowsPalette[12] = BGR(ccolor("LBLUE"));
windowsPalette[13] = BGR(ccolor("LMAGENTA"));
windowsPalette[14] = BGR(ccolor("LCYAN"));
windowsPalette[15] = BGR(ccolor("WHITE"));
return 0;
}
int curses_start_color(void)
{
//TODO: this should be reviewed in the future.
colorpairs = new pairs[100];
windowsPalette = new RGBQUAD[16];
//Load the console colors from colors.json
std::ifstream colorfile(FILENAMES["colors"].c_str(), std::ifstream::in | std::ifstream::binary);
try{
JsonIn jsin(colorfile);
char ch;
// Manually load the colordef object because the json handler isn't loaded yet.
jsin.eat_whitespace();
ch = jsin.peek();
if( ch == '[' ) {
jsin.start_array();
// find type and dispatch each object until array close
while (!jsin.end_array()) {
jsin.eat_whitespace();
char ch = jsin.peek();
if (ch != '{') {
jsin.error( string_format( "expected array of objects but found '%c', not '{'", ch ) );
}
JsonObject jo = jsin.get_object();
load_colors(jo);
jo.finish();
}
} else {
// not an array?
jsin.error( string_format( "expected object or array, but found '%c'", ch ) );
}
} catch( const JsonError &err ){
throw std::runtime_error( FILENAMES["colors"] + ": " + err.what() );
}
if(consolecolors.empty())return SetDIBColorTable(backbuffer, 0, 16, windowsPalette);
windowsPalette[0] = BGR(ccolor("BLACK"));
windowsPalette[1] = BGR(ccolor("RED"));
windowsPalette[2] = BGR(ccolor("GREEN"));
windowsPalette[3] = BGR(ccolor("BROWN"));
windowsPalette[4] = BGR(ccolor("BLUE"));
windowsPalette[5] = BGR(ccolor("MAGENTA"));
windowsPalette[6] = BGR(ccolor("CYAN"));
windowsPalette[7] = BGR(ccolor("GRAY"));
windowsPalette[8] = BGR(ccolor("DGRAY"));
windowsPalette[9] = BGR(ccolor("LRED"));
windowsPalette[10] = BGR(ccolor("LGREEN"));
windowsPalette[11] = BGR(ccolor("YELLOW"));
windowsPalette[12] = BGR(ccolor("LBLUE"));
windowsPalette[13] = BGR(ccolor("LMAGENTA"));
windowsPalette[14] = BGR(ccolor("LCYAN"));
windowsPalette[15] = BGR(ccolor("WHITE"));
return SetDIBColorTable(backbuffer, 0, 16, windowsPalette);
}
void zone_manager::load_zones()
{
std::string savefile = world_generator->active_world->world_path + "/" + base64_encode(
g->u.name ) + ".zones.json";
read_from_file_optional( savefile, [&]( std::istream & fin ) {
JsonIn jsin( fin );
deserialize( jsin );
} );
cache_data();
}
void zone_manager::load_zones()
{
std::string savefile = g->get_player_base_save_path() + ".zones.json";
read_from_file_optional( savefile, [&]( std::istream & fin ) {
JsonIn jsin( fin );
deserialize( jsin );
} );
revert_vzones();
added_vzones.clear();
changed_vzones.clear();
removed_vzones.clear();
cache_data();
}
void monster::load_info(std::string data)
{
std::stringstream dump;
dump << data;
if ( dump.peek() == '{' ) {
JsonIn jsin(dump);
try {
deserialize(jsin);
} catch (std::string jsonerr) {
debugmsg("monster:load_info: Bad monster json\n%s", jsonerr.c_str() );
}
return;
} else {
load_legacy(dump);
}
}
void mod_manager::load_mod_info(std::string info_file_path)
{
// info_file_path is the fully qualified path to the information file for this mod
std::ifstream infile(info_file_path.c_str(), std::ifstream::in | std::ifstream::binary);
if (!infile) {
// fail silently?
return;
}
std::istringstream iss(
std::string(
(std::istreambuf_iterator<char>(infile)),
std::istreambuf_iterator<char>()
)
);
infile.close();
const std::string main_path = info_file_path.substr(0, info_file_path.find_last_of("/\\"));
try {
JsonIn jsin(iss);
jsin.eat_whitespace();
char ch = jsin.peek();
if (ch == '{') {
// find type and dispatch single object
JsonObject jo = jsin.get_object();
load_modfile(jo, main_path);
jo.finish();
} else if (ch == '[') {
jsin.start_array();
// find type and dispatch each object until array close
while (!jsin.end_array()) {
jsin.eat_whitespace();
JsonObject jo = jsin.get_object();
load_modfile(jo, main_path);
jo.finish();
}
} else {
// not an object or an array?
std::stringstream err;
err << jsin.line_number() << ": ";
err << "expected object or array, but found '" << ch << "'";
throw err.str();
}
} catch(std::string e) {
debugmsg("%s", e.c_str());
}
}
void load_json_dir(std::string const &dirname)
{
// get a list of all files in the directory
std::vector<std::string> dir = listfiles(dirname);
// iterate over each file
std::vector<std::string>::iterator it;
for (it = dir.begin(); it != dir.end(); it++) {
// open the file as a stream
std::ifstream infile(it->c_str(), std::ifstream::in | std::ifstream::binary);
// parse it
try {
JsonIn jsin(&infile);
load_all_from_json(jsin);
} catch (std::string e) {
throw *(it) + ": " + e;
}
}
}
void DynamicDataLoader::load_data_from_path( const std::string &path, const std::string &src,
loading_ui &ui )
{
assert( !finalized && "Can't load additional data after finalization. Must be unloaded first." );
// We assume that each folder is consistent in itself,
// and all the previously loaded folders.
// E.g. the core might provide a vpart "frame-x"
// the first loaded mode might provide a vehicle that uses that frame
// But not the other way round.
// get a list of all files in the directory
str_vec files = get_files_from_path( ".json", path, true, true );
if( files.empty() ) {
std::ifstream tmp( path.c_str(), std::ios::in );
if( tmp ) {
// path is actually a file, don't checking the extension,
// assume we want to load this file anyway
files.push_back( path );
}
}
// iterate over each file
for( auto &files_i : files ) {
const std::string &file = files_i;
// open the file as a stream
std::ifstream infile( file.c_str(), std::ifstream::in | std::ifstream::binary );
// and stuff it into ram
std::istringstream iss(
std::string(
( std::istreambuf_iterator<char>( infile ) ),
std::istreambuf_iterator<char>()
)
);
try {
// parse it
JsonIn jsin( iss );
load_all_from_json( jsin, src, ui, path, file );
} catch( const JsonError &err ) {
throw std::runtime_error( file + ": " + err.what() );
}
}
}
void DynamicDataLoader::load_data_from_path(const std::string &path)
{
// We assume that each folder is consistent in itself,
// and all the previously loaded folders.
// E.g. the core might provide a vpart "frame-x"
// the first loaded mode might provide a vehicle that uses that frame
// But not the other way round.
// get a list of all files in the directory
str_vec files = file_finder::get_files_from_path(".json", path, true, true);
if (files.empty()) {
std::ifstream tmp(path.c_str(), std::ios::in);
if (tmp) {
// path is actually a file, don't checking the extension,
// assume we want to load this file anyway
files.push_back(path);
}
}
// iterate over each file
for (size_t i = 0; i < files.size(); i++) {
const std::string &file = files[i];
// open the file as a stream
std::ifstream infile(file.c_str(), std::ifstream::in | std::ifstream::binary);
// and stuff it into ram
std::istringstream iss(
std::string(
(std::istreambuf_iterator<char>(infile)),
std::istreambuf_iterator<char>()
)
);
try {
// parse it
JsonIn jsin(iss);
load_all_from_json(jsin);
} catch (std::string e) {
DebugLog() << file << ": " << e << "\n";
throw file + ": " + e;
}
}
}
void color_manager::load_custom(const std::string &sPath)
{
const auto file = ( sPath.empty() ) ? FILENAMES["custom_colors"] : sPath;
std::ifstream fin;
fin.open(file.c_str(), std::ifstream::in | std::ifstream::binary);
if( !fin.good() ) {
fin.close();
finalize(); // Need to finalize regardless of success
return;
}
try {
JsonIn jsin(fin);
deserialize(jsin);
} catch( const JsonError &e ) {
DebugLog(D_ERROR, DC_ALL) << "load_custom: " << e;
}
fin.close();
finalize();
}
bool DynamicDataLoader::load_deferred( deferred_json& data )
{
while( !data.empty() ) {
size_t n = static_cast<size_t>( data.size() );
auto it = data.begin();
for( size_t idx = 0; idx != n; ++idx ) {
try {
std::istringstream str( it->first );
JsonIn jsin( str );
JsonObject jo = jsin.get_object();
load_object( jo, it->second );
} catch( const std::exception &err ) {
debugmsg( "Error loading data from json: %s", err.what() );
}
++it;
}
data.erase( data.begin(), it );
if( data.size() == n ) {
return false; // made no progress on this cycle so abort
}
}
return true;
}
void safemode::load( const bool is_character_in )
{
is_character = is_character_in;
std::ifstream fin;
std::string file = FILENAMES["safemode"];
if( is_character ) {
file = world_generator->active_world->world_path + "/" + base64_encode( g->u.name ) + ".sfm.json";
}
fin.open( file.c_str(), std::ifstream::in | std::ifstream::binary );
if( fin.good() ) {
try {
JsonIn jsin( fin );
deserialize( jsin );
} catch( const JsonError &e ) {
DebugLog( D_ERROR, DC_ALL ) << "safemode::load: " << e;
}
}
fin.close();
create_rules();
}
void safemode::load( const bool is_character_in )
{
is_character = is_character_in;
std::ifstream fin;
std::string file = FILENAMES["safemode"];
if( is_character ) {
file = g->get_player_base_save_path() + ".sfm.json";
}
fin.open( file.c_str(), std::ifstream::in | std::ifstream::binary );
if( fin.good() ) {
try {
JsonIn jsin( fin );
deserialize( jsin );
} catch( const JsonError &e ) {
DebugLog( D_ERROR, DC_ALL ) << "safemode::load: " << e;
}
}
fin.close();
create_rules();
}
void mod_manager::load_mods_list(WORLDPTR world) const
{
if (world == NULL) {
return;
}
std::vector<std::string> &amo = world->active_mod_order;
amo.clear();
std::ifstream mods_list_file( get_mods_list_file(world).c_str(),
std::ios::in | std::ios::binary );
if (!mods_list_file) {
return;
}
bool obsolete_mod_found = false;
try {
JsonIn jsin(mods_list_file);
JsonArray ja = jsin.get_array();
while (ja.has_more()) {
const std::string mod = ja.next_string();
if( mod.empty() || std::find(amo.begin(), amo.end(), mod) != amo.end() ) {
continue;
}
if( obsolete_mod_list.count( mod ) ) {
obsolete_mod_found = true;
continue;
}
amo.push_back(mod);
}
} catch (std::string e) {
DebugLog( D_ERROR, DC_ALL ) << "worldfactory: loading mods list failed: " << e;
}
if( obsolete_mod_found ) {
// If we found an obsolete mod, overwrite the mod list without the obsolete one.
save_mods_list(world);
}
}
void item::load_info( const std::string &data )
{
std::istringstream dump(data);
char check=dump.peek();
if ( check == ' ' ) {
// sigh..
check=data[1];
}
if ( check == '{' ) {
JsonIn jsin(dump);
try {
deserialize(jsin);
} catch( const JsonError &jsonerr ) {
debugmsg("Bad item json\n%s", jsonerr.c_str() );
}
return;
}
unset_flags();
clear_vars();
std::string idtmp, ammotmp, item_tag, mode;
int lettmp, damtmp, acttmp, corp, tag_count;
int owned; // Ignoring an obsolete member.
dump >> lettmp >> idtmp >> charges >> damtmp >> tag_count;
for( int i = 0; i < tag_count; ++i )
{
dump >> item_tag;
if( itag2ivar(item_tag, item_vars ) == false ) {
item_tags.insert( item_tag );
}
}
dump >> burnt >> poison >> ammotmp >> owned >> bday >>
mode >> acttmp >> corp >> mission_id >> player_id;
corpse = NULL;
getline(dump, corpse_name);
if( corpse_name == " ''" ) {
corpse_name = "";
} else {
size_t pos = corpse_name.find_first_of( "@@" );
while (pos != std::string::npos) {
corpse_name.replace( pos, 2, "\n" );
pos = corpse_name.find_first_of( "@@" );
}
corpse_name = corpse_name.substr( 2, corpse_name.size() - 3 ); // s/^ '(.*)'$/\1/
}
gun_set_mode( mode );
if( idtmp == "UPS_on" ) {
idtmp = "UPS_off";
} else if( idtmp == "adv_UPS_on" ) {
idtmp = "adv_UPS_off" ;
}
convert( idtmp );
invlet = char(lettmp);
set_damage( damtmp );
active = false;
if (acttmp == 1) {
active = true;
}
}
int main( int argc, char *argv[] )
{
std::stringstream in;
std::stringstream out;
std::string filename;
std::string header;
char *gateway_var = getenv( "GATEWAY_INTERFACE" );
if( gateway_var == nullptr ) {
// Expect a single filename for now.
if( argc == 2 ) {
filename = argv[1];
} else if( argc != 1 ) {
std::cout << "Supply a filename to style or no arguments." << std::endl;
exit( EXIT_FAILURE );
}
if( filename.empty() ) {
in << std::cin.rdbuf();
} else {
std::ifstream fin( filename, std::ios::binary );
in << fin.rdbuf();
fin.close();
}
} else {
std::map<std::string, std::string> params;
initializePost( params );
std::string data = params[ "data" ];
if( data.empty() ) {
exit( -255 );
}
in.str( data );
header = "Content-type: application/json\n\n";
}
if( in.str().size() == 0 ) {
std::cout << "Error, input empty." << std::endl;
exit( EXIT_FAILURE );
}
JsonOut jsout( out, true );
JsonIn jsin( in );
format( jsin, jsout );
out << std::endl;
if( filename.empty() ) {
std::cout << header;
std::cout << out.str() << std::endl;
} else {
if( in.str() == out.str() ) {
std::cout << "Unformatted " << filename << std::endl;
exit( EXIT_SUCCESS );
} else {
std::ofstream fout( filename, std::ios::binary | std::ios::trunc );
fout << out.str();
fout.close();
std::cout << "Formatted " << filename << std::endl;
exit( EXIT_FAILURE );
}
}
}
// We're reading in way too many entities here to mess around with creating sub-objects and
// seeking around in them, so we're using the json streaming API.
submap *mapbuffer::unserialize_submaps( const tripoint &p )
{
// Map the tripoint to the submap quad that stores it.
const tripoint om_addr = overmapbuffer::sm_to_omt_copy( p );
const tripoint segment_addr = overmapbuffer::omt_to_seg_copy( om_addr );
std::stringstream quad_path;
quad_path << world_generator->active_world->world_path << "/maps/" <<
segment_addr.x << "." << segment_addr.y << "." << segment_addr.z << "/" <<
om_addr.x << "." << om_addr.y << "." << om_addr.z << ".map";
std::ifstream fin( quad_path.str().c_str() );
if( !fin.is_open() ) {
// If it doesn't exist, trigger generating it.
return NULL;
}
JsonIn jsin( fin );
jsin.start_array();
while( !jsin.end_array() ) {
std::unique_ptr<submap> sm(new submap());
tripoint submap_coordinates;
jsin.start_object();
while( !jsin.end_object() ) {
std::string submap_member_name = jsin.get_member_name();
if( submap_member_name == "version" ) {
// We aren't using the version number for anything at the moment.
jsin.skip_value();
} else if( submap_member_name == "coordinates" ) {
jsin.start_array();
int locx = jsin.get_int();
int locy = jsin.get_int();
int locz = jsin.get_int();
jsin.end_array();
submap_coordinates = tripoint( locx, locy, locz );
} else if( submap_member_name == "turn_last_touched" ) {
sm->turn_last_touched = jsin.get_int();
} else if( submap_member_name == "temperature" ) {
sm->temperature = jsin.get_int();
} else if( submap_member_name == "terrain" ) {
// TODO: try block around this to error out if we come up short?
jsin.start_array();
for( int j = 0; j < SEEY; j++ ) {
for( int i = 0; i < SEEX; i++ ) {
sm->ter[i][j] = termap[ jsin.get_string() ].loadid;
}
}
jsin.end_array();
} else if( submap_member_name == "radiation" ) {
int rad_cell = 0;
jsin.start_array();
while( !jsin.end_array() ) {
int rad_strength = jsin.get_int();
int rad_num = jsin.get_int();
for( int i = 0; i < rad_num; ++i ) {
// A little array trick here, assign to it as a 1D array.
// If it's not in bounds we're kinda hosed anyway.
sm->set_radiation(0, rad_cell, rad_strength);
rad_cell++;
}
}
} else if( submap_member_name == "furniture" ) {
jsin.start_array();
while( !jsin.end_array() ) {
jsin.start_array();
int i = jsin.get_int();
int j = jsin.get_int();
sm->frn[i][j] = furnmap[ jsin.get_string() ].loadid;
jsin.end_array();
}
} else if( submap_member_name == "items" ) {
jsin.start_array();
while( !jsin.end_array() ) {
int i = jsin.get_int();
int j = jsin.get_int();
jsin.start_array();
while( !jsin.end_array() ) {
item tmp;
jsin.read( tmp );
sm->itm[i][j].push_back( tmp );
}
}
} else if( submap_member_name == "traps" ) {
jsin.start_array();
while( !jsin.end_array() ) {
jsin.start_array();
int i = jsin.get_int();
int j = jsin.get_int();
sm->trp[i][j] = trapmap[ jsin.get_string() ];
jsin.end_array();
}
} else if( submap_member_name == "fields" ) {
jsin.start_array();
while( !jsin.end_array() ) {
// Coordinates loop
int i = jsin.get_int();
int j = jsin.get_int();
jsin.start_array();
while( !jsin.end_array() ) {
int type = jsin.get_int();
int density = jsin.get_int();
int age = jsin.get_int();
if (sm->fld[i][j].findField(field_id(type)) == NULL) {
sm->field_count++;
}
sm->fld[i][j].addField(field_id(type), density, age);
}
}
} else if( submap_member_name == "griffiti" ) {
jsin.start_array();
while( !jsin.end_array() ) {
jsin.start_array();
int i = jsin.get_int();
int j = jsin.get_int();
sm->set_graffiti(i, j, graffiti( jsin.get_string() ));
jsin.end_array();
}
} else if(submap_member_name == "cosmetics") {
jsin.start_array();
while (!jsin.end_array()) {
jsin.start_array();
int i = jsin.get_int();
int j = jsin.get_int();
jsin.read(sm->cosmetics[i][j]);
jsin.end_array();
}
} else if( submap_member_name == "spawns" ) {
jsin.start_array();
while( !jsin.end_array() ) {
jsin.start_array();
std::string type = jsin.get_string();
int count = jsin.get_int();
int i = jsin.get_int();
int j = jsin.get_int();
int faction_id = jsin.get_int();
int mission_id = jsin.get_int();
bool friendly = jsin.get_bool();
std::string name = jsin.get_string();
jsin.end_array();
spawn_point tmp( type, count, i, j, faction_id, mission_id, friendly, name );
sm->spawns.push_back( tmp );
}
} else if( submap_member_name == "vehicles" ) {
jsin.start_array();
while( !jsin.end_array() ) {
vehicle *tmp = new vehicle();
jsin.read( *tmp );
sm->vehicles.push_back( tmp );
}
} else if( submap_member_name == "computers" ) {
std::string computer_data = jsin.get_string();
sm->comp.load_data( computer_data );
} else if( submap_member_name == "camp" ) {
std::string camp_data = jsin.get_string();
sm->camp.load_data( camp_data );
} else {
jsin.skip_value();
}
}
if( !add_submap( submap_coordinates, sm ) ) {
debugmsg( "submap %d,%d,%d was alread loaded", submap_coordinates.x, submap_coordinates.y, submap_coordinates.z );
}
}
if( submaps.count( p ) == 0 ) {
debugmsg("file %s did not contain the expected submap %d,%d,%d", quad_path.str().c_str(), p.x, p.y, p.z);
return NULL;
}
return submaps[ p ];
}
void input_manager::init()
{
init_keycode_mapping();
std::ifstream data_file;
std::string file_name = "data/raw/keybindings.json";
data_file.open(file_name.c_str(), std::ifstream::in | std::ifstream::binary);
if(!data_file.good()) {
throw "Could not read " + file_name;
}
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");
actionID_to_name[action_id] = action.get_string("name", action_id);
const std::string context = action.get_string("category", "default");
// Iterate over the bindings JSON array
JsonArray bindings = action.get_array("bindings");
const bool defaultcontext = (context == "default");
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"))
);
}
if (defaultcontext) {
action_to_input[action_id].push_back(new_event);
} else {
action_contexts[context][action_id].push_back(new_event);
}
}
}
data_file.close();
}
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");
}
}
}
}
// We're reading in way too many entities here to mess around with creating sub-objects and
// seeking around in them, so we're using the json streaming API.
submap *mapbuffer::unserialize_submaps( const tripoint &p )
{
// Map the tripoint to the submap quad that stores it.
const tripoint om_addr = overmapbuffer::sm_to_omt_copy( p );
const tripoint segment_addr = overmapbuffer::omt_to_seg_copy( om_addr );
std::stringstream quad_path;
quad_path << world_generator->active_world->world_path << "/maps/" <<
segment_addr.x << "." << segment_addr.y << "." << segment_addr.z << "/" <<
om_addr.x << "." << om_addr.y << "." << om_addr.z << ".map";
std::ifstream fin( quad_path.str().c_str() );
if( !fin.is_open() ) {
// If it doesn't exist, trigger generating it.
return NULL;
}
JsonIn jsin( fin );
jsin.start_array();
while( !jsin.end_array() ) {
std::unique_ptr<submap> sm(new submap());
tripoint submap_coordinates;
jsin.start_object();
bool rubpow_update = false;
while( !jsin.end_object() ) {
std::string submap_member_name = jsin.get_member_name();
if( submap_member_name == "version" ) {
if (jsin.get_int() < 22) {
rubpow_update = true;
}
} else if( submap_member_name == "coordinates" ) {
jsin.start_array();
int locx = jsin.get_int();
int locy = jsin.get_int();
int locz = jsin.get_int();
jsin.end_array();
submap_coordinates = tripoint( locx, locy, locz );
} else if( submap_member_name == "turn_last_touched" ) {
sm->turn_last_touched = jsin.get_int();
} else if( submap_member_name == "temperature" ) {
sm->temperature = jsin.get_int();
} else if( submap_member_name == "terrain" ) {
// TODO: try block around this to error out if we come up short?
jsin.start_array();
// Small duplication here so that the update check is only performed once
if (rubpow_update) {
std::string ter_string;
item rock = item("rock", 0);
item chunk = item("steel_chunk", 0);
for( int j = 0; j < SEEY; j++ ) {
for( int i = 0; i < SEEX; i++ ) {
ter_string = jsin.get_string();
if (ter_string == "t_rubble") {
sm->ter[i][j] = termap[ "t_dirt" ].loadid;
sm->frn[i][j] = furnmap[ "f_rubble" ].loadid;
sm->itm[i][j].push_back( rock );
sm->itm[i][j].push_back( rock );
} else if (ter_string == "t_wreckage"){
sm->ter[i][j] = termap[ "t_dirt" ].loadid;
sm->frn[i][j] = furnmap[ "f_wreckage" ].loadid;
sm->itm[i][j].push_back( chunk );
sm->itm[i][j].push_back( chunk );
} else if (ter_string == "t_ash"){
sm->ter[i][j] = termap[ "t_dirt" ].loadid;
sm->frn[i][j] = furnmap[ "f_ash" ].loadid;
} else if (ter_string == "t_pwr_sb_support_l"){
sm->ter[i][j] = termap[ "t_support_l" ].loadid;
} else if (ter_string == "t_pwr_sb_switchgear_l"){
sm->ter[i][j] = termap[ "t_switchgear_l" ].loadid;
} else if (ter_string == "t_pwr_sb_switchgear_s"){
sm->ter[i][j] = termap[ "t_switchgear_s" ].loadid;
} else {
sm->ter[i][j] = terfind( ter_string );
}
}
}
} else {
for( int j = 0; j < SEEY; j++ ) {
for( int i = 0; i < SEEX; i++ ) {
sm->ter[i][j] = terfind( jsin.get_string() );
}
}
}
jsin.end_array();
} else if( submap_member_name == "radiation" ) {
int rad_cell = 0;
jsin.start_array();
while( !jsin.end_array() ) {
int rad_strength = jsin.get_int();
int rad_num = jsin.get_int();
for( int i = 0; i < rad_num; ++i ) {
// A little array trick here, assign to it as a 1D array.
// If it's not in bounds we're kinda hosed anyway.
sm->set_radiation(0, rad_cell, rad_strength);
rad_cell++;
}
}
} else if( submap_member_name == "furniture" ) {
jsin.start_array();
while( !jsin.end_array() ) {
jsin.start_array();
int i = jsin.get_int();
int j = jsin.get_int();
sm->frn[i][j] = furnmap[ jsin.get_string() ].loadid;
jsin.end_array();
}
} else if( submap_member_name == "items" ) {
jsin.start_array();
while( !jsin.end_array() ) {
int i = jsin.get_int();
int j = jsin.get_int();
jsin.start_array();
while( !jsin.end_array() ) {
item tmp;
jsin.read( tmp );
if( tmp.is_emissive() ) {
sm->update_lum_add(tmp, i, j);
}
tmp.visit_items([&sm,i,j]( item *it ) {
for( auto& e: it->magazine_convert() ) {
sm->itm[i][j].push_back( e );
}
return VisitResponse::NEXT;
} );
sm->itm[i][j].push_back( tmp );
if( tmp.needs_processing() ) {
sm->active_items.add( std::prev(sm->itm[i][j].end()), point( i, j ) );
}
}
}
} else if( submap_member_name == "traps" ) {
jsin.start_array();
while( !jsin.end_array() ) {
jsin.start_array();
int i = jsin.get_int();
int j = jsin.get_int();
// TODO: jsin should support returning an id like jsin.get_id<trap>()
sm->trp[i][j] = trap_str_id( jsin.get_string() );
jsin.end_array();
}
} else if( submap_member_name == "fields" ) {
jsin.start_array();
while( !jsin.end_array() ) {
// Coordinates loop
int i = jsin.get_int();
int j = jsin.get_int();
jsin.start_array();
while( !jsin.end_array() ) {
int type = jsin.get_int();
int density = jsin.get_int();
int age = jsin.get_int();
if (sm->fld[i][j].findField(field_id(type)) == NULL) {
sm->field_count++;
}
sm->fld[i][j].addField(field_id(type), density, age);
}
}
} else if( submap_member_name == "graffiti" ) {
jsin.start_array();
while( !jsin.end_array() ) {
jsin.start_array();
int i = jsin.get_int();
int j = jsin.get_int();
sm->set_graffiti( i, j, jsin.get_string() );
jsin.end_array();
}
} else if(submap_member_name == "cosmetics") {
jsin.start_array();
while (!jsin.end_array()) {
jsin.start_array();
int i = jsin.get_int();
int j = jsin.get_int();
jsin.read(sm->cosmetics[i][j]);
jsin.end_array();
}
} else if( submap_member_name == "spawns" ) {
jsin.start_array();
while( !jsin.end_array() ) {
jsin.start_array();
const mtype_id type = mtype_id( jsin.get_string() ); // TODO: json should know how to read an string_id
int count = jsin.get_int();
int i = jsin.get_int();
int j = jsin.get_int();
int faction_id = jsin.get_int();
int mission_id = jsin.get_int();
bool friendly = jsin.get_bool();
std::string name = jsin.get_string();
jsin.end_array();
spawn_point tmp( type, count, i, j, faction_id, mission_id, friendly, name );
sm->spawns.push_back( tmp );
}
} else if( submap_member_name == "vehicles" ) {
jsin.start_array();
while( !jsin.end_array() ) {
vehicle *tmp = new vehicle();
jsin.read( *tmp );
sm->vehicles.push_back( tmp );
}
} else if( submap_member_name == "computers" ) {
std::string computer_data = jsin.get_string();
sm->comp.load_data( computer_data );
} else if( submap_member_name == "camp" ) {
std::string camp_data = jsin.get_string();
sm->camp.load_data( camp_data );
} else {
jsin.skip_value();
}
}
if( !add_submap( submap_coordinates, sm ) ) {
debugmsg( "submap %d,%d,%d was already loaded", submap_coordinates.x, submap_coordinates.y,
submap_coordinates.z );
}
}
if( submaps.count( p ) == 0 ) {
debugmsg("file %s did not contain the expected submap %d,%d,%d", quad_path.str().c_str(), p.x, p.y,
p.z);
return NULL;
}
return submaps[ p ];
}
void deserialize_wrapper( const std::function<void( JsonIn & )> &callback, const std::string &data )
{
std::istringstream buffer( data );
JsonIn jsin( buffer );
callback( jsin );
}
void vpart_info::finalize()
{
auto& dyn = DynamicDataLoader::get_instance();
while( !deferred.empty() ) {
auto n = deferred.size();
auto it = deferred.begin();
for( decltype(deferred)::size_type idx = 0; idx != n; ++idx ) {
try {
std::istringstream str( it->first );
JsonIn jsin( str );
JsonObject jo = jsin.get_object();
dyn.load_object( jo, it->second );
} catch( const std::exception &err ) {
debugmsg( "Error loading data from json: %s", err.what() );
}
++it;
}
deferred.erase( deferred.begin(), it );
if( deferred.size() == n ) {
debugmsg( "JSON contains circular dependency: discarded %i templates", n );
break;
}
}
for( auto& e : vehicle_part_types ) {
// if part name specified ensure it is translated
// otherwise the name of the base item will be used
if( !e.second.name_.empty() ) {
e.second.name_ = _( e.second.name_.c_str() );
}
if( e.second.folded_volume > 0 ) {
e.second.set_flag( "FOLDABLE" );
}
for( const auto& f : e.second.flags ) {
auto b = vpart_bitflag_map.find( f );
if( b != vpart_bitflag_map.end() ) {
e.second.bitflags.set( b->second );
}
}
// Calculate and cache z-ordering based off of location
// list_order is used when inspecting the vehicle
if( e.second.location == "on_roof" ) {
e.second.z_order = 9;
e.second.list_order = 3;
} else if( e.second.location == "on_cargo" ) {
e.second.z_order = 8;
e.second.list_order = 6;
} else if( e.second.location == "center" ) {
e.second.z_order = 7;
e.second.list_order = 7;
} else if( e.second.location == "under" ) {
// Have wheels show up over frames
e.second.z_order = 6;
e.second.list_order = 10;
} else if( e.second.location == "structure" ) {
e.second.z_order = 5;
e.second.list_order = 1;
} else if( e.second.location == "engine_block" ) {
// Should be hidden by frames
e.second.z_order = 4;
e.second.list_order = 8 ;
} else if( e.second.location == "on_battery_mount" ){
// Should be hidden by frames
e.second.z_order = 3;
e.second.list_order = 10;
} else if( e.second.location == "fuel_source" ) {
// Should be hidden by frames
e.second.z_order = 3;
e.second.list_order = 9;
} else if( e.second.location == "roof" ) {
// Shouldn't be displayed
e.second.z_order = -1;
e.second.list_order = 4;
} else if( e.second.location == "armor" ) {
// Shouldn't be displayed (the color is used, but not the symbol)
e.second.z_order = -2;
e.second.list_order = 2;
} else {
// Everything else
e.second.z_order = 0;
e.second.list_order = 5;
}
}
}
JNIEXPORT jdouble JNICALL
Java_java_lang_StrictMath_sin(JNIEnv *env, jclass unused, jdouble d)
{
return (jdouble) jsin((double)d);
}