/**
* Reads engine info from a JsonObject.
*/
void vpart_info::load_engine( cata::optional<vpslot_engine> &eptr, JsonObject &jo,
const itype_id &fuel_type )
{
vpslot_engine e_info;
if( eptr ) {
e_info = *eptr;
}
assign( jo, "backfire_threshold", e_info.backfire_threshold );
assign( jo, "backfire_freq", e_info.backfire_freq );
assign( jo, "noise_factor", e_info.noise_factor );
assign( jo, "damaged_power_factor", e_info.damaged_power_factor );
assign( jo, "m2c", e_info.m2c );
assign( jo, "muscle_power_factor", e_info.muscle_power_factor );
auto excludes = jo.get_array( "exclusions" );
if( !excludes.empty() ) {
e_info.exclusions.clear();
while( excludes.has_more() ) {
e_info.exclusions.push_back( excludes.next_string() );
}
}
auto fuel_opts = jo.get_array( "fuel_options" );
if( !fuel_opts.empty() ) {
e_info.fuel_opts.clear();
while( fuel_opts.has_more() ) {
e_info.fuel_opts.push_back( itype_id( fuel_opts.next_string() ) );
}
} else if( e_info.fuel_opts.empty() && fuel_type != itype_id( "null" ) ) {
e_info.fuel_opts.push_back( fuel_type );
}
eptr = e_info;
assert( eptr );
}
int next_twins (
u64 key,
u64 *next_key,
char *name)
{
char name_a[MAX_NAME+1];
char name_b[MAX_NAME+1];
u64 next_a;
u64 next_b;
int rc_a;
int rc_b;
rc_a = next_string( &TreeA, key, &next_a, name_a);
rc_b = next_string( &TreeB, key, &next_b, name_b);
if (rc_a && (rc_a == rc_b)) {
return rc_a;
}
if ((rc_a != rc_b)
|| (next_a != next_b)
|| (strcmp(name_a, name_b) != 0))
{
printf("Failed next_twins %d ? %d %llx ? %llx %s ? %s\n",
rc_a, rc_b, next_a, next_b, name_a, name_b);
}
if (!rc_a) {
*next_key = next_a;
strcpy(name, name_a);
}
return rc_a;
}
int libxl__restore_emulator_xenstore_data(libxl__domain_create_state *dcs,
const char *ptr, uint32_t size)
{
STATE_AO_GC(dcs->ao);
const char *next = ptr, *end = ptr + size, *key, *val;
int rc;
const uint32_t domid = dcs->guest_domid;
const uint32_t dm_domid = libxl_get_stubdom_id(CTX, domid);
const char *xs_root = DEVICE_MODEL_XS_PATH(gc, dm_domid, domid, "");
while (next < end) {
key = next;
next = next_string(next, end);
/* Sanitise 'key'. */
if (!next) {
rc = ERROR_FAIL;
LOG(ERROR, "Key in xenstore data not NUL terminated");
goto out;
}
if (key[0] == '\0') {
rc = ERROR_FAIL;
LOG(ERROR, "empty key found in xenstore data");
goto out;
}
if (key[0] == '/') {
rc = ERROR_FAIL;
LOG(ERROR, "Key in xenstore data not relative");
goto out;
}
val = next;
next = next_string(next, end);
/* Sanitise 'val'. */
if (!next) {
rc = ERROR_FAIL;
LOG(ERROR, "Val in xenstore data not NUL terminated");
goto out;
}
libxl__xs_printf(gc, XBT_NULL,
GCSPRINTF("%s/%s", xs_root, key),
"%s", val);
}
rc = 0;
out:
return rc;
}
static int parse_line (FILE * in, struct athlete_data * athlete)
{
char readbuf[BUFSIZE];
char * scanner;
char tmp[2];
if (NULL == fgets(readbuf, BUFSIZE, in)) {
return 1;
}
scanner = readbuf;
if (0 > next_string(&scanner, athlete->first_name, STRSIZE)) {
return -1;
}
if (0 > next_string(&scanner, athlete->last_name, STRSIZE)) {
return -2;
}
if (0 > next_string(&scanner, athlete->country, STRSIZE)) {
return -3;
}
if (0 > next_string(&scanner, athlete->sport, STRSIZE)) {
return -4;
}
if (0 > next_number(&scanner, &athlete->age)) {
return -5;
}
if (0 > next_number(&scanner, &athlete->height)) {
return -6;
}
if (0 > next_number(&scanner, &athlete->weight)) {
return -7;
}
if (0 > next_string(&scanner, tmp, 2)) {
return -8;
}
switch (tmp[0]) {
case 'f':
case 'F':
athlete->gender = FEMALE;
break;
case 'm':
case 'M':
athlete->gender = MALE;
break;
default:
return -9;
}
return 0;
}
string countAndSay(int n) {
string start = "1";
for (int i = 2; i <= n; ++i) {
start = next_string(start);
}
return start;
}
string_iterator_t *next_string_iterator(string_iterator_t *self) {
if(self != NULL) {
free(self->current_string);
self->current_string = next_string(self);
self->good = (self->current_string != NULL);
}
return self;
}
static int next_number (char ** scanner, int * number)
{
char string[STRSIZE];
int status;
status = next_string (scanner, string, STRSIZE);
if (1 != sscanf (string, "%d", number)) {
return -3;
}
return status;
}
static char *get_modinfo(struct secthdr *sechdrs,
unsigned int info, const char *tag)
{
char *p;
unsigned int taglen = strlen(tag);
unsigned long size = sechdrs[info].sh_size;
for (p = (char *)sechdrs[info].sh_addr; p; p = next_string(p, &size)) {
if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
return p + taglen + 1;
}
return NULL;
}
static char *get_modinfo(void *modinfo, unsigned long modinfo_len,
const char *tag)
{
char *p;
unsigned int taglen = strlen(tag);
unsigned long size = modinfo_len;
for (p = modinfo; p; p = next_string(p, &size)) {
if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
return p + taglen + 1;
}
return NULL;
}
void quality::load( JsonObject &jo, const std::string & )
{
mandatory( jo, was_loaded, "name", name, translated_string_reader );
JsonArray arr = jo.get_array( "usages" );
while( arr.has_more() ) {
auto lvl = arr.next_array();
auto funcs = lvl.get_array( 1 );
while( funcs.has_more() ) {
usages.emplace_back( lvl.get_int( 0 ), funcs.next_string() );
}
}
}
int ep (int argc, char *argvp[])
{
u64 key;
char name[MAX_NAME+1];
int rc;
for (key = 0; key != 0xffffffffffffffffULL;) {
rc = next_string(key, &key, name);
if (rc) break;
printf("%llu %s\n", key-1, name);
}
return 0;
}
string_iterator_t *new_string_iterator(const char *source,
const char *delimiters) {
string_iterator_t *self = malloc(sizeof(string_iterator_t));
self->source = calloc(strlen(source) + 1, sizeof(char));
strcpy(self->source, source);
self->delimiters = calloc(strlen(delimiters) + 1, sizeof(char));
strcpy(self->delimiters, delimiters);
self->next_position = 0;
next_position(self);
self->current_string = next_string(self);
self->good = (self->current_string != NULL);
return self;
}
int apply (int (*fn)(char *, void *), void *data)
{
u64 key;
int rc;
char name[MAX_NAME+1];
for (key = 0;;) {
if (next_string(key, &key, name) != 0) {
break;
}
rc = fn(name, data);
if (rc) {
return rc;
}
}
return 0;
}
int expand (char *p, int (fn)(char *))
{
u64 key;
int rc;
char name[MAX_NAME+1];
for (key = 0;;) {
rc = next_string(key, &key, name);
if (rc) break;
if (isMatch(p, name)) {
rc = fn(name);
if (rc) {
return rc;
}
}
}
return 0;
}
void AccountMap::Unused( const ID& id ) {
int target_score = 1;
int len = id.size();
int min_len = len - 1;
int max_len = (len+1 < 100) ? (len+1):100;
int output = 0;
bool comma = false;
SkipListNode* temp;
string test;
if (min_len == 0) {
test = "0";
} else {
test = id.substr(0, min_len);
}
while (output < 10) {
if (calculate_score(test, id) == target_score && !Find(test, temp)) {
if (comma) {
cout << ',';
}
cout << test;
comma = true;
output += 1;
}
if (!next_string(test, min_len, max_len)) {
target_score += 1;
min_len = (min_len == 0) ? 0:(min_len-1);
if (max_len != 100 &&
(max_len+1-len+1)*(max_len+1-len)/2 <= target_score)
{
max_len += 1;
}
if (min_len == 0) {
test = "0";
} else {
test = id.substr(0, min_len);
}
}
}
}
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 );
}
}
void material_type::load( JsonObject &jsobj, const std::string & )
{
mandatory( jsobj, was_loaded, "name", _name );
mandatory( jsobj, was_loaded, "bash_resist", _bash_resist );
mandatory( jsobj, was_loaded, "cut_resist", _cut_resist );
mandatory( jsobj, was_loaded, "acid_resist", _acid_resist );
mandatory( jsobj, was_loaded, "elec_resist", _elec_resist );
mandatory( jsobj, was_loaded, "fire_resist", _fire_resist );
mandatory( jsobj, was_loaded, "chip_resist", _chip_resist );
mandatory( jsobj, was_loaded, "density", _density );
assign( jsobj, "salvaged_into", _salvaged_into );
optional( jsobj, was_loaded, "repaired_with", _repaired_with, "null" );
optional( jsobj, was_loaded, "edible", _edible, false );
optional( jsobj, was_loaded, "soft", _soft, false );
auto arr = jsobj.get_array( "vitamins" );
while( arr.has_more() ) {
auto pair = arr.next_array();
_vitamins.emplace( vitamin_id( pair.get_string( 0 ) ), pair.get_float( 1 ) );
}
mandatory( jsobj, was_loaded, "bash_dmg_verb", _bash_dmg_verb );
mandatory( jsobj, was_loaded, "cut_dmg_verb", _cut_dmg_verb );
JsonArray jsarr = jsobj.get_array( "dmg_adj" );
while( jsarr.has_more() ) {
_dmg_adj.push_back( jsarr.next_string() );
}
JsonArray burn_data_array = jsobj.get_array( "burn_data" );
for( size_t intensity = 0; intensity < MAX_FIELD_DENSITY; intensity++ ) {
if( burn_data_array.has_more() ) {
JsonObject brn = burn_data_array.next_object();
_burn_data[ intensity ] = load_mat_burn_data( brn );
} else {
// If not specified, supply default
bool flammable = _fire_resist <= static_cast<int>( intensity );
mat_burn_data mbd;
if( flammable ) {
mbd.burn = 1;
}
_burn_data[ intensity ] = mbd;
}
}
auto bp_array = jsobj.get_array( "burn_products" );
while( bp_array.has_more( ) ) {
auto pair = bp_array.next_array();
_burn_products.emplace_back( pair.get_string( 0 ), static_cast< float >( pair.get_float( 1 ) ) );
}
auto compactor_in_array = jsobj.get_array( "compact_accepts" );
while( compactor_in_array.has_more( ) ) {
_compact_accepts.emplace_back( compactor_in_array.next_string() );
}
auto compactor_out_array = jsobj.get_array( "compacts_into" );
while( compactor_out_array.has_more( ) ) {
_compacts_into.emplace_back( compactor_out_array.next_string() );
}
}
/* http://lxr.linux.no/linux+v2.6.29/drivers/char/apm-emulation.c */
SDL_bool
SDL_GetPowerInfo_Linux_proc_apm(SDL_PowerState * state,
int *seconds, int *percent)
{
SDL_bool need_details = SDL_FALSE;
int ac_status = 0;
int battery_status = 0;
int battery_flag = 0;
int battery_percent = 0;
int battery_time = 0;
const int fd = open(proc_apm_path, O_RDONLY);
char buf[128];
char *ptr = &buf[0];
char *str = NULL;
ssize_t br;
if (fd == -1) {
return SDL_FALSE; /* can't use this interface. */
}
br = read(fd, buf, sizeof (buf) - 1);
close(fd);
if (br < 0) {
return SDL_FALSE;
}
buf[br] = '\0'; /* null-terminate the string. */
if (!next_string(&ptr, &str)) { /* driver version */
return SDL_FALSE;
}
if (!next_string(&ptr, &str)) { /* BIOS version */
return SDL_FALSE;
}
if (!next_string(&ptr, &str)) { /* APM flags */
return SDL_FALSE;
}
if (!next_string(&ptr, &str)) { /* AC line status */
return SDL_FALSE;
} else if (!int_string(str, &ac_status)) {
return SDL_FALSE;
}
if (!next_string(&ptr, &str)) { /* battery status */
return SDL_FALSE;
} else if (!int_string(str, &battery_status)) {
return SDL_FALSE;
}
if (!next_string(&ptr, &str)) { /* battery flag */
return SDL_FALSE;
} else if (!int_string(str, &battery_flag)) {
return SDL_FALSE;
}
if (!next_string(&ptr, &str)) { /* remaining battery life percent */
return SDL_FALSE;
}
if (str[strlen(str) - 1] == '%') {
str[strlen(str) - 1] = '\0';
}
if (!int_string(str, &battery_percent)) {
return SDL_FALSE;
}
if (!next_string(&ptr, &str)) { /* remaining battery life time */
return SDL_FALSE;
} else if (!int_string(str, &battery_time)) {
return SDL_FALSE;
}
if (!next_string(&ptr, &str)) { /* remaining battery life time units */
return SDL_FALSE;
} else if (strcmp(str, "min") == 0) {
battery_time *= 60;
}
if (battery_flag == 0xFF) { /* unknown state */
*state = SDL_POWERSTATE_UNKNOWN;
} else if (battery_flag & (1 << 7)) { /* no battery */
*state = SDL_POWERSTATE_NO_BATTERY;
} else if (battery_flag & (1 << 3)) { /* charging */
*state = SDL_POWERSTATE_CHARGING;
need_details = SDL_TRUE;
} else if (ac_status == 1) {
*state = SDL_POWERSTATE_CHARGED; /* on AC, not charging. */
need_details = SDL_TRUE;
} else {
*state = SDL_POWERSTATE_ON_BATTERY;
need_details = SDL_TRUE;
}
*percent = -1;
*seconds = -1;
if (need_details) {
const int pct = battery_percent;
const int secs = battery_time;
if (pct >= 0) { /* -1 == unknown */
*percent = (pct > 100) ? 100 : pct; /* clamp between 0%, 100% */
}
if (secs >= 0) { /* -1 == unknown */
*seconds = secs;
}
}
return SDL_TRUE;
}
int main(int argc, char **argv)
{
char *me = argv[0], *data, **new_argv;
char *exe_path, *lib_path, *dll_path;
int start, prog_end, end, count, fd, v, en, x11;
int argpos, inpos, collcount = 1, fix_argv;
if (config[7] == '[') {
write_str(2, argv[0]);
write_str(2, ": this is an unconfigured starter\n");
return 1;
}
if (me[0] == '/') {
/* Absolute path */
} else if (has_slash(me)) {
/* Relative path with a directory: */
char *buf;
long buflen = 4096;
buf = (char *)malloc(buflen);
me = path_append(getcwd(buf, buflen), me);
} else {
/* We have to find the executable by searching PATH: */
char *path = copy_string(getenv("PATH")), *p, *m;
int more;
if (!path) {
path = "";
}
while (1) {
/* Try each element of path: */
for (p = path; *p && (*p != ':'); p++) { }
if (*p) {
*p = 0;
more = 1;
} else
more = 0;
if (!*path)
break;
m = path_append(path, me);
if (executable_exists(m)) {
if (m[0] != '/')
m = path_append(getcwd(NULL, 0), m);
me = m;
break;
}
free(m);
if (more)
path = p + 1;
else
break;
}
}
/* me is now an absolute path to the binary */
/* resolve soft links */
while (1) {
int len, bufsize = 127;
char *buf;
buf = (char *)malloc(bufsize + 1);
len = readlink(me, buf, bufsize);
if (len < 0) {
if (errno == ENAMETOOLONG) {
/* Increase buffer size and try again: */
bufsize *= 2;
buf = (char *)malloc(bufsize + 1);
} else
break;
} else {
/* Resolve buf relative to me: */
buf[len] = 0;
buf = absolutize(buf, me);
me = buf;
buf = (char *)malloc(bufsize + 1);
}
}
start = as_int(config + 8);
prog_end = as_int(config + 12);
end = as_int(config + 16);
count = as_int(config + 20);
x11 = as_int(config + 24);
fix_argv = try_elf_section(me, &start, &prog_end, &end);
{
int offset, len;
offset = _coldir_offset;
while (1) {
len = strlen(_coldir + offset);
offset += len + 1;
if (!_coldir[offset])
break;
collcount++;
}
}
data = (char *)malloc(end - prog_end);
new_argv = (char **)malloc((count + argc + (2 * collcount) + 8) * sizeof(char*));
fd = open(me, O_RDONLY, 0);
lseek(fd, prog_end, SEEK_SET);
{
int expected_length = end - prog_end;
if (expected_length != read(fd, data, expected_length)) {
printf("read failed to read all %i bytes from file %s\n", expected_length, me);
abort();
}
}
close(fd);
exe_path = data;
data = next_string(data);
lib_path = data;
data = next_string(data);
exe_path = absolutize(exe_path, me);
lib_path = absolutize(lib_path, me);
# ifdef OS_X
# define LD_LIB_PATH "DYLD_LIBRARY_PATH"
# else
# define LD_LIB_PATH "LD_LIBRARY_PATH"
# endif
if (*lib_path) {
dll_path = getenv(LD_LIB_PATH);
if (!dll_path) {
dll_path = "";
}
dll_path = string_append(dll_path, ":");
dll_path = string_append(lib_path, dll_path);
dll_path = string_append(LD_LIB_PATH "=", dll_path);
putenv(dll_path);
}
new_argv[0] = me;
argpos = 1;
inpos = 1;
/* Keep all X11 flags to the front: */
if (x11) {
int n;
while (inpos < argc) {
n = is_x_flag(argv[inpos]);
if (!n)
break;
if (inpos + n > argc) {
write_str(2, argv[0]);
write_str(2, ": missing an argument for ");
write_str(2, argv[inpos]);
write_str(2, "\n");
return 1;
}
while (n--) {
new_argv[argpos++] = argv[inpos++];
}
}
}
/* Add -X and -S flags */
{
int offset, len;
offset = _coldir_offset;
new_argv[argpos++] = "-X";
new_argv[argpos++] = absolutize(_coldir + offset, me);
while (1) {
len = strlen(_coldir + offset);
offset += len + 1;
if (!_coldir[offset])
break;
new_argv[argpos++] = "-S";
new_argv[argpos++] = absolutize(_coldir + offset, me);
}
}
if (fix_argv) {
/* next three args are "-k" and numbers; fix
the numbers to match start and prog_end */
fix_argv = argpos + 1;
}
/* Add built-in flags: */
while (count--) {
new_argv[argpos++] = data;
data = next_string(data);
}
/* Propagate new flags (after the X11 flags) */
while (inpos < argc) {
new_argv[argpos++] = argv[inpos++];
}
new_argv[argpos] = NULL;
if (fix_argv) {
new_argv[fix_argv] = num_to_string(start);
new_argv[fix_argv+1] = num_to_string(prog_end);
}
/* Execute the original binary: */
v = execv(exe_path, new_argv);
en = errno;
write_str(2, argv[0]);
write_str(2, ": failed to start ");
write_str(2, exe_path);
write_str(2, " (");
write_str(2, strerror(en));
write_str(2, ")\n");
if (*lib_path) {
write_str(2, " used library path ");
write_str(2, lib_path);
write_str(2, "\n");
}
return v;
}
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 ) );
}
}
/* http://lxr.linux.no/linux+v2.6.29/drivers/char/apm-emulation.c */
bool PowerX11::GetPowerInfo_Linux_proc_apm() {
bool need_details = false;
int ac_status = 0;
int battery_status = 0;
int battery_flag = 0;
int battery_percent = 0;
int battery_time = 0;
FileAccessRef fd = FileAccess::open(proc_apm_path, FileAccess::READ);
char buf[128];
char *ptr = &buf[0];
char *str = NULL;
ssize_t br;
if (!fd) {
return false; /* can't use this interface. */
}
br = fd->get_buffer(reinterpret_cast<uint8_t *>(buf), sizeof(buf) - 1);
fd->close();
if (br < 0) {
return false;
}
buf[br] = '\0'; /* null-terminate the string. */
if (!next_string(&ptr, &str)) { /* driver version */
return false;
}
if (!next_string(&ptr, &str)) { /* BIOS version */
return false;
}
if (!next_string(&ptr, &str)) { /* APM flags */
return false;
}
if (!next_string(&ptr, &str)) { /* AC line status */
return false;
} else if (!int_string(str, &ac_status)) {
return false;
}
if (!next_string(&ptr, &str)) { /* battery status */
return false;
} else if (!int_string(str, &battery_status)) {
return false;
}
if (!next_string(&ptr, &str)) { /* battery flag */
return false;
} else if (!int_string(str, &battery_flag)) {
return false;
}
if (!next_string(&ptr, &str)) { /* remaining battery life percent */
return false;
}
String sstr = str;
if (sstr[sstr.length() - 1] == '%') {
sstr[sstr.length() - 1] = '\0';
}
if (!int_string(str, &battery_percent)) {
return false;
}
if (!next_string(&ptr, &str)) { /* remaining battery life time */
return false;
} else if (!int_string(str, &battery_time)) {
return false;
}
if (!next_string(&ptr, &str)) { /* remaining battery life time units */
return false;
} else if (String(str) == "min") {
battery_time *= 60;
}
if (battery_flag == 0xFF) { /* unknown state */
this->power_state = OS::POWERSTATE_UNKNOWN;
} else if (battery_flag & (1 << 7)) { /* no battery */
this->power_state = OS::POWERSTATE_NO_BATTERY;
} else if (battery_flag & (1 << 3)) { /* charging */
this->power_state = OS::POWERSTATE_CHARGING;
need_details = true;
} else if (ac_status == 1) {
this->power_state = OS::POWERSTATE_CHARGED; /* on AC, not charging. */
need_details = true;
} else {
this->power_state = OS::POWERSTATE_ON_BATTERY;
need_details = true;
}
this->percent_left = -1;
this->nsecs_left = -1;
if (need_details) {
const int pct = battery_percent;
const int secs = battery_time;
if (pct >= 0) { /* -1 == unknown */
this->percent_left = (pct > 100) ? 100 : pct; /* clamp between 0%, 100% */
}
if (secs >= 0) { /* -1 == unknown */
this->nsecs_left = secs;
}
}
return true;
}
