void mutation_branch::load_trait_group( JsonObject &jsobj, const trait_group::Trait_group_tag &gid,
const std::string &subtype )
{
if( subtype != "distribution" && subtype != "collection" && subtype != "old" ) {
jsobj.throw_error( "unknown trait group type", "subtype" );
}
Trait_group &tg = make_group_or_throw( gid, ( subtype == "collection" || subtype == "old" ) );
// TODO: (sm) Looks like this makes the new code backwards-compatible with the old format. Great if so!
if( subtype == "old" ) {
JsonArray traits = jsobj.get_array( "traits" );
while( traits.has_more() ) {
JsonArray pair = traits.next_array();
tg.add_trait_entry( trait_id( pair.get_string( 0 ) ), pair.get_int( 1 ) );
}
return;
}
// TODO: (sm) Taken from item_factory.cpp almost verbatim. Ensure that these work!
if( jsobj.has_member( "entries" ) ) {
JsonArray traits = jsobj.get_array( "entries" );
while( traits.has_more() ) {
JsonObject subobj = traits.next_object();
add_entry( tg, subobj );
}
}
if( jsobj.has_member( "traits" ) ) {
JsonArray traits = jsobj.get_array( "traits" );
while( traits.has_more() ) {
if( traits.test_string() ) {
tg.add_trait_entry( trait_id( traits.next_string() ), 100 );
} else if( traits.test_array() ) {
JsonArray subtrait = traits.next_array();
tg.add_trait_entry( trait_id( subtrait.get_string( 0 ) ), subtrait.get_int( 1 ) );
} else {
JsonObject subobj = traits.next_object();
add_entry( tg, subobj );
}
}
}
if( jsobj.has_member( "groups" ) ) {
JsonArray traits = jsobj.get_array( "groups" );
while( traits.has_more() ) {
if( traits.test_string() ) {
tg.add_group_entry( trait_group::Trait_group_tag( traits.next_string() ), 100 );
} else if( traits.test_array() ) {
JsonArray subtrait = traits.next_array();
tg.add_group_entry( trait_group::Trait_group_tag( traits.get_string( 0 ) ), subtrait.get_int( 1 ) );
} else {
JsonObject subobj = traits.next_object();
add_entry( tg, subobj );
}
}
}
}
void MonsterGenerator::load_special_attacks(mtype *m, JsonObject &jo, std::string member) {
m->special_attacks.clear(); // make sure we're running with everything cleared
if( !jo.has_array( member ) ) {
return;
}
JsonArray outer = jo.get_array(member);
while( outer.has_more() ) {
if( outer.test_array() ) {
JsonArray inner = outer.next_array();
const auto &aname = inner.get_string(0);
if ( attack_map.find(aname) != attack_map.end() ) {
auto new_entry = mtype_special_attack(
attack_map[aname], inner.get_int(1) );
m->special_attacks[aname] = new_entry;
m->special_attacks_names.push_back(aname);
} else {
inner.throw_error("Invalid special_attacks");
}
} else if( outer.test_object() ) {
set_attack_from_object(
outer.next_object(), m->special_attacks, m->special_attacks_names );
} else {
outer.throw_error( "array element is neither array nor object." );
}
}
}
json_item_substitution::trait_requirements json_item_substitution::trait_requirements::load(
JsonArray &arr )
{
trait_requirements ret;
arr.read_next( ret.present );
if( arr.test_array() ) {
arr.read_next( ret.absent );
}
return ret;
}
void mtype::add_special_attacks( JsonObject &jo, const std::string &member ) {
if( !jo.has_array( member ) ) {
return;
}
JsonArray outer = jo.get_array(member);
while( outer.has_more() ) {
if( outer.test_array() ) {
add_special_attack( outer.next_array() );
} else if( outer.test_object() ) {
add_special_attack( outer.next_object() );
} else {
outer.throw_error( "array element is neither array nor object." );
}
}
}
void requirements::load_obj_list(JsonArray &jsarr, std::vector< std::vector<T> > &objs) {
while (jsarr.has_more()) {
if(jsarr.test_array()) {
std::vector<T> choices;
JsonArray ja = jsarr.next_array();
while (ja.has_more()) {
choices.push_back(T());
choices.back().load(ja);
}
if( !choices.empty() ) {
objs.push_back( choices );
}
} else {
// tool qualities don't normally use a list of alternatives
// each quality is mandatory.
objs.push_back(std::vector<T>(1));
objs.back().back().load(jsarr);
}
}
}
void mutation_branch::load_trait_group( JsonArray &entries, const trait_group::Trait_group_tag &gid,
const bool is_collection )
{
Trait_group &tg = make_group_or_throw( gid, is_collection );
while( entries.has_more() ) {
// Backwards-compatibility with old format ["TRAIT", 100]
if( entries.test_array() ) {
JsonArray subarr = entries.next_array();
trait_id id( subarr.get_string( 0 ) );
std::unique_ptr<Trait_creation_data> ptr(
new Single_trait_creator( id, subarr.get_int( 1 ) ) );
tg.add_entry( ptr );
// Otherwise load new format {"trait": ... } or {"group": ...}
} else {
JsonObject subobj = entries.next_object();
add_entry( tg, subobj );
}
}
}
