void load_effect_type(JsonObject &jo)
{
effect_type new_etype;
new_etype.id = jo.get_string("id");
new_etype.name = jo.get_string("name", "");
new_etype.desc = jo.get_string("desc", "");
new_etype.apply_message = jo.get_string("apply_message", "");
new_etype.remove_message = jo.get_string("remove_message", "");
new_etype.apply_memorial_log = jo.get_string("apply_memorial_log", "");
new_etype.remove_memorial_log = jo.get_string("remove_memorial_log", "");
effect_types[new_etype.id] = new_etype;
}
bool map_deconstruct_info::load(JsonObject &jsobj, std::string member, bool isfurniture)
{
if (!jsobj.has_object(member)) {
return false;
}
JsonObject j = jsobj.get_object(member);
furn_set = j.get_string("furn_set", "");
if (!isfurniture) {
ter_set = j.get_string("ter_set");
}
can_do = true;
load_map_bash_item_drop_list(j.get_array("items"), items);
return true;
}
bool map_deconstruct_info::load(JsonObject &jsobj, std::string member, bool isfurniture)
{
if (!jsobj.has_object(member)) {
return false;
}
JsonObject j = jsobj.get_object(member);
furn_set = j.get_string("furn_set", "");
if (!isfurniture) {
ter_set = j.get_string( "ter_set" );
}
can_do = true;
JsonIn& stream = *j.get_raw( "items" );
drop_group = item_group::load_item_group( stream, "collection" );
return true;
}
void sfx::load_playlist( JsonObject &jsobj )
{
if( !sound_init_success ) {
return;
}
JsonArray jarr = jsobj.get_array( "playlists" );
while( jarr.has_more() ) {
JsonObject playlist = jarr.next_object();
const std::string playlist_id = playlist.get_string( "id" );
music_playlist playlist_to_load;
playlist_to_load.shuffle = playlist.get_bool( "shuffle", false );
JsonArray files = playlist.get_array( "files" );
while( files.has_more() ) {
JsonObject entry = files.next_object();
const music_playlist::entry e{ entry.get_string( "file" ), entry.get_int( "volume" ) };
playlist_to_load.entries.push_back( e );
}
playlists[playlist_id] = std::move( playlist_to_load );
}
}
void Comment::setData(const JsonObject &data, bool signalChange)
{
QString id = JSON_GET_STRING(data.value(COMMENT_ID_KEY));
QString name = JSON_GET_STRING(data.value(COMMENT_NAME_KEY));
QString url = JSON_GET_STRING(data.value(COMMENT_URL_KEY));
QString dateString = JSON_GET_STRING(data.value(COMMENT_DATE_KEY));
QDateTime date = QDateTime::fromString(dateString, DATE_TIME_FORMAT);
QString content = JSON_GET_STRING(data.value(COMMENT_CONTENT_KEY));
QString parent = JSON_GET_STRING(data.value(COMMENT_PARENT_KEY));
if (m_id != id) {
m_id = id;
if (signalChange) {
emit idChanged();
}
}
if (m_name != name) {
m_name = name;
if (signalChange) {
emit nameChanged();
}
}
if (m_url != url) {
m_url = url;
if (signalChange) {
emit urlChanged();
}
}
if (m_date != date) {
m_date = date;
if (signalChange) {
emit dateChanged();
}
}
if (m_content != content) {
m_content = content;
if (signalChange) {
emit contentChanged();
}
}
if (m_parent != parent) {
m_parent = parent;
if (signalChange) {
emit parentChanged();
}
}
}
void visitFunctionStatement(FunctionStatement *node) override {
JsonObject *obj = new (pool_) JsonObject();
obj->add(atom_name_, toJson(node->name()));
startDoc(obj, "function", node->name(), node->loc());
if (node->token() == TOK_FORWARD)
obj->add(atom_kind_, toJson("forward"));
else if (node->token() == TOK_NATIVE)
obj->add(atom_kind_, toJson("native"));
else
obj->add(atom_kind_, toJson("stock"));
obj->add(atom_returnType_, toJson(node->signature()->returnType()));
obj->add(atom_parameters_, toJson(node->signature()->parameters()));
functions_->add(obj);
}
bool TournamentConfig::Save(const std::string &fileName)
{
bool ret = true;
JsonObject json;
json.AddValue("version", TOURNAMENT_CONFIG_VERSION);
JsonArray tournament;
for (std::vector<Tarot::Distribution>::iterator iter = mOptions.turns.begin(); iter != mOptions.turns.end(); ++iter)
{
std::string type;
std::string file;
std::uint32_t number = 0U;
JsonObject obj;
if (iter->mType == Tarot::Distribution::RANDOM_DEAL)
{
type = "random";
file = "";
}
else if (iter->mType == Tarot::Distribution::CUSTOM_DEAL)
{
type = "custom";
file = iter->mFile;
}
else
{
type = "numbered";
number = iter->mSeed;
}
obj.AddValue("type", type);
obj.AddValue("file", file);
obj.AddValue("number", number);
tournament.AddValue(obj);
}
json.AddValue("tournament", tournament);
if (!JsonWriter::SaveToFile(json, fileName))
{
ret = false;
TLogError("Saving tournament's configuration failed.");
}
return ret;
}
int cRooms::setOffsetTime( JsonObject& root )
{
int fail=0;
int succes=0;
if(root.containsKey("Rt")) {
if(root["Rt"].is<JsonArray&>()){
JsonArray& times = root["Rt"];
if (times.size()==(nSetTypes*nRoomTypes*nDayTypes*nSwitch))
{
for(int iSet = 0; iSet<nSetTypes; iSet++)
{
for(int iRoomType = 0; iRoomType<nRoomTypes; iRoomType++) // Iterate over all Roomtypes (Living, sleeping, hallway, side)
{
for(int iDayType = 0; iDayType<nDayTypes; iDayType++)
{
for(int iSwitch = 0; iSwitch<nSwitch; iSwitch++)
{
int idx = iSwitch+iDayType*(nSwitch)+iRoomType*(nDayTypes)*(nSwitch)+iSet*(nRoomTypes)*(nDayTypes)*(nSwitch);
if (times[idx].is<long>()) {
unsigned long oldTime = TempOffsetSchedule[iSet][iRoomType][iDayType][iSwitch].time.totalseconds();
unsigned long newTime = times[idx].as<long>();
if((newTime>=0)&&(24*60*60-newTime>=0)&&(newTime!=oldTime)){
TempOffsetSchedule[iSet][iRoomType][iDayType][iSwitch].time.set(newTime);
succes=1;
}
}
else fail=1;
}
}
}
}
}
}
}
return (!fail)&&(succes);
}
void visitTypesetDecl(TypesetDecl *decl) override {
JsonObject *obj = new (pool_) JsonObject();
obj->add(atom_name_, toJson(decl->name()));
startDoc(obj, "typeset", decl->name(), decl->loc());
JsonList *list = new (pool_) JsonList();
for (size_t i = 0; i < decl->types()->length(); i++) {
const TypesetDecl::Entry &entry = decl->types()->at(i);
JsonObject *te = new (pool_) JsonObject();
te->add(atom_type_, toJson(entry.te));
unsigned start, end;
if (comments_.findCommentFor(entry.loc, &start, &end)) {
te->add(atom_doc_start_, new (pool_) JsonInt(start));
te->add(atom_doc_end_, new (pool_) JsonInt(end));
}
list->add(te);
}
obj->add(cc_.add("types"), list);
typesets_->add(obj);
}
int cRooms::setOffsetTemp( JsonObject& root )
{
int fail=0;
int succes=0;
if(root.containsKey("RTo")) {
if(root["RTo"].is<JsonArray&>()){
JsonArray& temps = root["RTo"];
if (temps.size()==(nSetTypes*nRoomTypes*nDayTypes*nSwitch))
{
for(int iSet = 0; iSet<nSetTypes; iSet++) // Normal
{
for(int iRoomType = 0; iRoomType<nRoomTypes; iRoomType++) // (Living, sleeping, hallway, bath, side)
{
for(int iDayType = 0; iDayType<nDayTypes; iDayType++) // Weekend, Workday
{
for(int iSwitch = 0; iSwitch<nSwitch; iSwitch++) // 4 switch times
{
// Last iteration
int idx = iSwitch+iDayType*(nSwitch)+iRoomType*(nDayTypes)*(nSwitch)+iSet*(nRoomTypes)*(nDayTypes)*(nSwitch);
if (temps[idx].is<double>()){
double temp_ = temps[idx].as<double>();
if((temp_>-15.0)&&(temp_<15.0)&&(temp_!=TempOffsetSchedule[iSet][iRoomType][iDayType][iSwitch].temp)){
TempOffsetSchedule[iSet][iRoomType][iDayType][iSwitch].temp = temp_;
succes = 1;
}
}
else fail=1;
}
}
}
}
}
}
}
return ((!fail)&&(succes));
}
void furn_t::load( JsonObject &jo, const std::string &src )
{
map_data_common_t::load( jo, src );
mandatory( jo, was_loaded, "name", name_ );
mandatory( jo, was_loaded, "move_cost_mod", movecost );
mandatory( jo, was_loaded, "required_str", move_str_req );
optional( jo, was_loaded, "max_volume", max_volume, legacy_volume_reader, DEFAULT_MAX_VOLUME_IN_SQUARE );
optional( jo, was_loaded, "crafting_pseudo_item", crafting_pseudo_item, "" );
optional( jo, was_loaded, "deployed_item", deployed_item );
load_symbol( jo );
transparent = false;
for( auto & flag : jo.get_string_array( "flags" ) ) {
set_flag( flag );
}
optional( jo, was_loaded, "open", open, string_id_reader<furn_t> {}, furn_str_id::NULL_ID() );
optional( jo, was_loaded, "close", close, string_id_reader<furn_t> {}, furn_str_id::NULL_ID() );
bash.load( jo, "bash", true );
deconstruct.load( jo, "deconstruct", true );
}
distribution load_distribution( JsonObject &jo, const std::string &name )
{
if( !jo.has_member( name ) ) {
return distribution();
}
if( jo.has_float( name ) ) {
return distribution::constant( jo.get_float( name ) );
}
if( jo.has_object( name ) ) {
JsonObject obj = jo.get_object( name );
return load_distribution( obj );
}
jo.throw_error( "Invalid distribution type", name );
return distribution();
}
bool DriveCommand::fromJson(JsonObject& cmd) {
if(!cmd.containsKey("type")) return false;
const char* type = cmd["type"];
if(strcmp(type, "SET_HEADING") == 0) {
command = SET_HEADING;
} else if(strcmp(type, "DRIVE") == 0) {
command = DRIVE;
} else {
Serial.print("unrecognized type ");
Serial.println(type);
return false;
}
if(!cmd.containsKey("cid") || !cmd.containsKey("pid") || !cmd.containsKey("duration")) {
return false;
}
cid = cmd["cid"];
pid = cmd["pid"];
duration = cmd["duration"];
if(command == DRIVE) {
if(!cmd.containsKey("speed") || !cmd.containsKey("heading")) return false;
payload.drive.speed = cmd["speed"];
payload.drive.heading = cmd["heading"];
return true;
} else if(command == SET_HEADING) {
if(!cmd.containsKey("heading")) return false;
payload.heading.heading = cmd["heading"];
return true;
} else {
return false;
}
}
void load_bionic(JsonObject &jsobj)
{
std::string id = jsobj.get_string("id");
std::string name = _(jsobj.get_string("name").c_str());
std::string description = _(jsobj.get_string("description").c_str());
int cost = jsobj.get_int("cost", 0);
int time = jsobj.get_int("time", 0);
bool faulty = jsobj.get_bool("faulty", false);
bool power_source = jsobj.get_bool("power_source", false);
bool active = jsobj.get_bool("active", false);
if (faulty) {
faulty_bionics.push_back(id);
}
if (power_source) {
power_source_bionics.push_back(id);
}
if (!active) {
unpowered_bionics.push_back(id);
}
bionics[id] = new bionic_data(name, power_source, active, cost, time, description, faulty);
}
bool map_bash_info::load(JsonObject &jsobj, std::string member, bool isfurniture) {
if( jsobj.has_object(member) ) {
JsonObject j = jsobj.get_object(member);
if ( jsonint(j, "num_tests", num_tests ) == false ) {
if ( jsonint(j, "str_min", str_min ) && jsonint(j, "str_max", str_max ) ) {
num_tests = 1;
}
} else if ( num_tests > 0 ) {
str_min = j.get_int("str_min");
str_max = j.get_int("str_max");
}
jsonint(j, "str_min_blocked", str_min_blocked );
jsonint(j, "str_max_blocked", str_max_blocked );
jsonint(j, "str_min_roll", str_min_roll );
jsonint(j, "explosive", explosive );
jsonint(j, "chance", chance );
jsonstring(j, "sound", sound );
jsonstring(j, "sound_fail", sound_fail );
jsonstring(j, "furn_set", furn_set );
if ( jsonstring(j, "ter_set", ter_set ) == false && isfurniture == false ) {
ter_set = "t_rubble";
debugmsg("terrain[\"%s\"].bash.ter_set is not set!",jsobj.get_string("id").c_str() );
}
if ( j.has_array("items") ) {
load_map_bash_item_drop_list(j.get_array("items"), items);
}
//debugmsg("%d/%d %s %s/%s %d",str_min,str_max, ter_set.c_str(), sound.c_str(), sound_fail.c_str(), items.size() );
return true;
} else {
return false;
}
}
void safemode::deserialize( JsonIn &jsin )
{
auto &temp_rules = ( is_character ) ? character_rules : global_rules;
temp_rules.clear();
jsin.start_array();
while( !jsin.end_array() ) {
JsonObject jo = jsin.get_object();
const std::string rule = jo.get_string( "rule" );
const bool active = jo.get_bool( "active" );
const bool whitelist = jo.get_bool( "whitelist" );
const Creature::Attitude attitude = ( Creature::Attitude ) jo.get_int( "attitude" );
const int proximity = jo.get_int( "proximity" );
temp_rules.push_back(
rules_class( rule, active, whitelist, attitude, proximity )
);
}
}
void requirement_data::load_requirement( JsonObject &jsobj, const std::string &id )
{
requirement_data req;
JsonArray jsarr;
jsarr = jsobj.get_array( "components" );
req.load_obj_list( jsarr, req.components );
jsarr = jsobj.get_array( "qualities" );
req.load_obj_list( jsarr, req.qualities );
jsarr = jsobj.get_array( "tools" );
req.load_obj_list( jsarr, req.tools );
if( !id.empty() ) {
req.id_ = requirement_id( id );
} else if( jsobj.has_string( "id" ) ) {
req.id_ = requirement_id( jsobj.get_string( "id" ) );
} else {
jsobj.throw_error( "id was not specified for requirement" );
}
save_requirement( req );
}
JsonList *toJson(const ParameterList *params) {
JsonList *list = new (pool_) JsonList();
for (size_t i = 0; i < params->length(); i++) {
VarDecl *decl = params->at(i);
JsonObject *obj = new (pool_) JsonObject();
obj->add(atom_type_, toJson(decl, false));
if (decl->name()) {
obj->add(atom_name_, toJson(decl->name()));
obj->add(atom_decl_, toJson(decl, true));
} else {
obj->add(atom_name_, toJson("..."));
AutoString builder = BuildTypeName(decl->te(), nullptr, TypeDiagFlags::Names);
builder = builder + " ...";
obj->add(atom_decl_, toJson(builder.ptr()));
}
list->add(obj);
}
return list;
}
bool Comment::isValid(const JsonObject &data)
{
if (!data.contains(COMMENT_ID_KEY)) {
return false;
}
if (!data.contains(COMMENT_NAME_KEY)) {
return false;
}
if (!data.contains(COMMENT_URL_KEY)) {
return false;
}
if (!data.contains(COMMENT_DATE_KEY)) {
return false;
}
if (!data.contains(COMMENT_CONTENT_KEY)) {
return false;
}
if (!data.contains(COMMENT_PARENT_KEY)) {
return false;
}
return true;
}
JsonObject *analyze(ParseTree *tree) {
functions_ = new (pool_) JsonList();
methodmaps_ = new (pool_) JsonList();
enums_ = new (pool_) JsonList();
constants_ = new (pool_) JsonList();
typesets_ = new (pool_) JsonList();
typedefs_ = new (pool_) JsonList();
for (size_t i = 0; i < tree->statements()->length(); i++) {
Statement *stmt = tree->statements()->at(i);
stmt->accept(this);
}
JsonObject *obj = new (pool_) JsonObject();
obj->add(cc_.add("functions"), functions_);
obj->add(cc_.add("methodmaps"), methodmaps_);
obj->add(cc_.add("enums"), enums_);
obj->add(cc_.add("constants"), constants_);
obj->add(cc_.add("typesets"), typesets_);
obj->add(cc_.add("typedefs"), typedefs_);
return obj;
}
void load_season_array( JsonObject &jo, const std::string &key, C &container, F load_func )
{
if( jo.has_string( key ) ) {
container.fill( load_func( jo.get_string( key ) ) );
} else if( jo.has_array( key ) ) {
auto arr = jo.get_array( key );
if( arr.size() == 1 ) {
container.fill( load_func( arr.get_string( 0 ) ) );
} else if( arr.size() == container.size() ) {
for( auto &e : container ) {
e = load_func( arr.next_string() );
}
} else {
jo.throw_error( "Incorrect number of entries", key );
}
} else {
jo.throw_error( "Expected string or array", key );
}
}
/*
* Handle the universe list callback
* @param response the HTTPResponse that is associated with the request.
* @param plugins a list of plugins
* @param error an error string.
*/
void OladHTTPServer::HandleUniverseList(HTTPResponse *response,
JsonObject *json,
const vector<OlaUniverse> &universes,
const string &error) {
if (error.empty()) {
JsonArray *universe_json = json->AddArray("universes");
vector<OlaUniverse>::const_iterator iter;
for (iter = universes.begin(); iter != universes.end(); ++iter) {
JsonObject *universe = universe_json->AppendObject();
universe->Add("id", iter->Id());
universe->Add("input_ports", iter->InputPortCount());
universe->Add("name", iter->Name());
universe->Add("output_ports", iter->OutputPortCount());
universe->Add("rdm_devices", iter->RDMDeviceCount());
}
}
response->SetNoCache();
response->SetContentType(HTTPServer::CONTENT_TYPE_PLAIN);
response->SendJson(*json);
delete response;
delete json;
}
void fault::load_fault( JsonObject &jo )
{
fault f;
f.id_ = fault_id( jo.get_string( "id" ) );
f.name_ = _( jo.get_string( "name" ).c_str() );
f.description_ = _( jo.get_string( "description" ).c_str() );
auto sk = jo.get_array( "skills" );
while( sk.has_more() ) {
auto cur = sk.next_array();
f.skills_.emplace( skill_id( cur.get_string( 0 ) ) , cur.size() >= 2 ? cur.get_int( 1 ) : 1 );
}
auto req = jo.get_object( "requirements" );
f.requirements_.load( req );
if( faults_all.find( f.id_ ) != faults_all.end() ) {
jo.throw_error( "parsed fault overwrites existing definition", "id" );
} else {
faults_all[ f.id_ ] = f;
DebugLog( D_INFO, DC_ALL ) << "Loaded fault: " << f.name_;
}
}
void MonsterGenerator::load_species(JsonObject &jo)
{
// id, flags, triggers (anger, placate, fear)
std::string sid;
if (jo.has_member("id")){
sid = jo.get_string("id");
std::set<std::string> sflags, sanger, sfear, splacate;
sflags = jo.get_tags("flags");
sanger = jo.get_tags("anger_triggers");
sfear = jo.get_tags("fear_triggers");
splacate = jo.get_tags("placate_triggers");
std::set<m_flag> flags = get_set_from_tags(sflags, flag_map, MF_NULL);
std::set<monster_trigger> anger, fear, placate;
anger = get_set_from_tags(sanger, trigger_map, MTRIG_NULL);
fear = get_set_from_tags(sfear, trigger_map, MTRIG_NULL);
placate = get_set_from_tags(splacate, trigger_map, MTRIG_NULL);
species_type *new_species = new species_type(sid, flags, anger, fear, placate);
mon_species[sid] = new_species;
}
}
void mission_type::load( JsonObject &jo, const std::string &src )
{
const bool strict = src == "dda";
mandatory( jo, was_loaded, "name", name );
mandatory( jo, was_loaded, "difficulty", difficulty );
mandatory( jo, was_loaded, "value", value );
if( jo.has_member( "origins" ) ) {
origins.clear();
for( auto &m : jo.get_tags( "origins" ) ) {
origins.emplace_back( io::string_to_enum_look_up( io::origin_map, m ) );
}
}
if( std::any_of( origins.begin(), origins.end(), []( mission_origin origin ) {
return origin == ORIGIN_ANY_NPC || origin == ORIGIN_OPENER_NPC || origin == ORIGIN_SECONDARY;
} ) ) {
auto djo = jo.get_object( "dialogue" );
// TODO: There should be a cleaner way to do it
mandatory( djo, was_loaded, "describe", dialogue[ "describe" ] );
mandatory( djo, was_loaded, "offer", dialogue[ "offer" ] );
mandatory( djo, was_loaded, "accepted", dialogue[ "accepted" ] );
mandatory( djo, was_loaded, "rejected", dialogue[ "rejected" ] );
mandatory( djo, was_loaded, "advice", dialogue[ "advice" ] );
mandatory( djo, was_loaded, "inquire", dialogue[ "inquire" ] );
mandatory( djo, was_loaded, "success", dialogue[ "success" ] );
mandatory( djo, was_loaded, "success_lie", dialogue[ "success_lie" ] );
mandatory( djo, was_loaded, "failure", dialogue[ "failure" ] );
}
optional( jo, was_loaded, "urgent", urgent );
optional( jo, was_loaded, "item", item_id );
optional( jo, was_loaded, "count", item_count, 1 );
goal = jo.get_enum_value<decltype( goal )>( "goal" );
assign_function( jo, "place", place, tripoint_function_map );
if( jo.has_string( "start" ) ) {
assign_function( jo, "start", start, mission_function_map );
} else if( jo.has_member( "start" ) ) {
JsonObject j_start = jo.get_object( "start" );
parse_start( j_start );
}
assign_function( jo, "end", end, mission_function_map );
assign_function( jo, "fail", fail, mission_function_map );
assign( jo, "deadline_low", deadline_low, false, 1_days );
assign( jo, "deadline_high", deadline_high, false, 1_days );
if( jo.has_member( "followup" ) ) {
follow_up = mission_type_id( jo.get_string( "followup" ) );
}
if( jo.has_member( "monster_species" ) ) {
monster_species = species_id( jo.get_string( "monster_species" ) );
}
if( jo.has_member( "monster_type" ) ) {
monster_type = mtype_id( jo.get_string( "monster_type" ) );
}
if( jo.has_member( "monster_kill_goal" ) ) {
monster_kill_goal = jo.get_int( "monster_kill_goal" );
}
assign( jo, "destination", target_id, strict );
}
void load_trap(JsonObject &jo)
{
std::vector<std::string> drops;
if(jo.has_member("drops")) {
JsonArray drops_list = jo.get_array("drops");
while(drops_list.has_more()) {
drops.push_back(drops_list.next_string());
}
}
std::string name = jo.get_string("name");
if (!name.empty()) {
name = _(name.c_str());
}
trap *new_trap = new trap(
jo.get_string("id"), // "tr_beartrap"
traplist.size(), // tr_beartrap
name, // "bear trap"
color_from_string(jo.get_string("color")),
jo.get_string("symbol").at(0),
jo.get_int("visibility"),
jo.get_int("avoidance"),
jo.get_int("difficulty"),
trap_function_from_string(jo.get_string("action")),
drops
);
new_trap->benign = jo.get_bool("benign", false);
new_trap->funnel_radius_mm = jo.get_int("funnel_radius", 0);
new_trap->trigger_weight = jo.get_int("trigger_weight", -1);
trapmap[new_trap->id] = new_trap->loadid;
traplist.push_back(new_trap);
}
addiction get_next( JsonIn &jin ) const {
JsonObject jo = jin.get_object();
return addiction( addiction_type( jo.get_string( "type" ) ), jo.get_int( "intensity" ) );
}
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" ) );
}
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" ) );
}
g.is_animal = jo.get_bool( "is_animal", false );
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;
}
int curses_start_color(void)
{
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 != '{') {
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 FILENAMES["colors"] + ": " + e;
}
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);
}