static enum parser_error parse_prefs_k(struct parser *p)
{
int tvi, svi, idx;
object_kind *kind;
struct prefs_data *d = parser_priv(p);
assert(d != NULL);
if (d->bypass)
return PARSE_ERROR_NONE;
tvi = tval_find_idx(parser_getsym(p, "tval"));
if (tvi < 0)
return PARSE_ERROR_UNRECOGNISED_TVAL;
svi = lookup_sval(tvi, parser_getsym(p, "sval"));
if (svi < 0)
return PARSE_ERROR_UNRECOGNISED_SVAL;
idx = lookup_kind(tvi, svi);
if (idx < 0)
return PARSE_ERROR_UNRECOGNISED_SVAL;
kind = &k_info[idx];
kind->x_attr = (byte) parser_getint(p, "attr");
kind->x_char = (wchar_t) parser_getint(p, "char");
return PARSE_ERROR_NONE;
}
static enum parser_error parse_prefs_q(struct parser *p)
{
struct prefs_data *d = parser_priv(p);
assert(d != NULL);
if (d->bypass)
return PARSE_ERROR_NONE;
if (parser_hasval(p, "sval") && parser_hasval(p, "flag")) {
object_kind *kind;
int tvi, svi, idx;
tvi = tval_find_idx(parser_getsym(p, "n"));
if (tvi < 0)
return PARSE_ERROR_UNRECOGNISED_TVAL;
svi = lookup_sval(tvi, parser_getsym(p, "sval"));
if (svi < 0)
return PARSE_ERROR_UNRECOGNISED_SVAL;
idx = lookup_kind(tvi, svi);
if (idx < 0)
return PARSE_ERROR_UNRECOGNISED_SVAL;
kind = &k_info[idx];
kind->squelch = parser_getint(p, "flag");
}
return PARSE_ERROR_NONE;
}
static enum parser_error parse_r_drop(struct parser *p) {
struct monster_race *r = parser_priv(p);
struct monster_drop *d;
int tval, sval;
if (!r)
return PARSE_ERROR_MISSING_RECORD_HEADER;
tval = tval_find_idx(parser_getsym(p, "tval"));
if (tval < 0)
return PARSE_ERROR_UNRECOGNISED_TVAL;
sval = lookup_sval(tval, parser_getsym(p, "sval"));
if (sval < 0)
return PARSE_ERROR_UNRECOGNISED_SVAL;
if (parser_getuint(p, "min") > 99 || parser_getuint(p, "max") > 99)
return PARSE_ERROR_INVALID_ITEM_NUMBER;
d = mem_zalloc(sizeof *d);
d->kind = objkind_get(tval, sval);
d->percent_chance = parser_getuint(p, "chance");
d->min = parser_getuint(p, "min");
d->max = parser_getuint(p, "max");
d->next = r->drops;
r->drops = d;
return PARSE_ERROR_NONE;
}
static enum parser_error parse_room_tval(struct parser *p) {
struct room_template *t = parser_priv(p);
int tval;
if (!t)
return PARSE_ERROR_MISSING_RECORD_HEADER;
tval = tval_find_idx(parser_getsym(p, "tval"));
if (tval < 0)
return PARSE_ERROR_UNRECOGNISED_TVAL;
t->tval = tval;
return PARSE_ERROR_NONE;
}
static enum parser_error parse_buy(struct parser *p) {
struct store *s = parser_priv(p);
struct object_buy *buy;
if (!s)
return PARSE_ERROR_MISSING_RECORD_HEADER;
buy = mem_zalloc(sizeof(*buy));
buy->tval = tval_find_idx(parser_getstr(p, "base"));
buy->next = s->buy;
s->buy = buy;
return PARSE_ERROR_NONE;
}
/**
* Counts the svals (from object.txt) of a given non-null tval
*/
int tval_sval_count(const char *name)
{
size_t i, num = 0;
int tval = tval_find_idx(name);
if (tval < 0) return 0;
for (i = 0; i < z_info->k_max; i++) {
struct object_kind *kind = &k_info[i];
if (!kind->tval) continue;
if (kind->tval != tval) continue;
num++;
}
return num;
}
static enum parser_error parse_prefs_e(struct parser *p)
{
int tvi, a;
struct prefs_data *d = parser_priv(p);
assert(d != NULL);
if (d->bypass) return PARSE_ERROR_NONE;
tvi = tval_find_idx(parser_getsym(p, "tval"));
if (tvi < 0 || tvi >= (long)N_ELEMENTS(tval_to_attr))
return PARSE_ERROR_UNRECOGNISED_TVAL;
a = parser_getint(p, "attr");
if (a) tval_to_attr[tvi] = (byte) a;
return PARSE_ERROR_NONE;
}
int test_defaults(void *state) {
size_t i;
struct monster_base *mb = lookup_monster_base("giant");
int tval = tval_find_idx("sword");
/* Monster bases */
eq(process_pref_file_command("monster-base:giant:3:3"), 0);
for (i = 0; i < z_info->r_max; i++) {
monster_race *race = &r_info[i];
if (race->base != mb) continue;
eq(monster_x_attr[race->ridx], 3);
eq(monster_x_char[race->ridx], 3);
}
/* Object tvals */
eq(process_pref_file_command("object:sword:*:3:3"), 0);
for (i = 0; i < z_info->k_max; i++) {
struct object_kind *kind = &k_info[i];
if (kind->tval != tval)
continue;
eq(kind_x_attr[kind->kidx], 3);
eq(kind_x_char[kind->kidx], 3);
}
/* Traps */
eq(process_pref_file_command("trap:*:*:3:3"), 0);
for (i = 0; i < z_info->trap_max; i++) {
int light_idx;
for (light_idx = 0; light_idx < LIGHTING_MAX; light_idx++) {
eq(trap_x_attr[light_idx][i], 3);
eq(trap_x_attr[light_idx][i], 3);
}
}
ok;
}
/**
* Lists up to max_size svals (from object.txt) of a given non-null tval
* Assumes list has allocated space for at least max_size elements
*/
int tval_sval_list(const char *name, int *list, int max_size)
{
size_t i;
int num = 0;
int tval = tval_find_idx(name);
if (tval < 0) return 0;
for (i = 0; i < z_info->k_max; i++) {
struct object_kind *kind = &k_info[i];
if (!kind->tval) continue;
if (kind->tval != tval) continue;
if (num >= max_size) break;
list[num++] = kind->sval;
}
return num;
}
static enum parser_error parse_buy_flag(struct parser *p) {
struct store *s = parser_priv(p);
struct object_buy *buy;
char *t;
int flag;
if (!s)
return PARSE_ERROR_MISSING_RECORD_HEADER;
buy = mem_zalloc(sizeof(*buy));
t = string_make(parser_getsym(p, "flag"));
flag = lookup_flag(obj_flags, t);
if (flag == FLAG_END)
return PARSE_ERROR_INVALID_FLAG;
buy->flag = flag;
buy->tval = tval_find_idx(parser_getstr(p, "base"));
buy->next = s->buy;
s->buy = buy;
return PARSE_ERROR_NONE;
}
static enum parser_error parse_r_mimic(struct parser *p) {
struct monster_race *r = parser_priv(p);
int tval, sval;
object_kind *kind;
if (!r)
return PARSE_ERROR_MISSING_RECORD_HEADER;
tval = tval_find_idx(parser_getsym(p, "tval"));
if (tval < 0)
return PARSE_ERROR_UNRECOGNISED_TVAL;
sval = lookup_sval(tval, parser_getsym(p, "sval"));
if (sval < 0)
return PARSE_ERROR_UNRECOGNISED_SVAL;
kind = objkind_get(tval, sval);
if (!kind)
return PARSE_ERROR_GENERIC;
r->mimic_kind = kind;
return PARSE_ERROR_NONE;
}
static enum parser_error parse_always(struct parser *p) {
struct store *s = parser_priv(p);
int tval = tval_find_idx(parser_getsym(p, "tval"));
int sval = lookup_sval(tval, parser_getsym(p, "sval"));
object_kind *kind = lookup_kind(tval, sval);
if (!kind)
return PARSE_ERROR_UNRECOGNISED_SVAL;
/* Expand if necessary */
if (!s->always_num) {
s->always_size = 8;
s->always_table = mem_zalloc(s->always_size * sizeof *s->always_table);
} else if (s->always_num >= s->always_size) {
s->always_size += 8;
s->always_table = mem_realloc(s->always_table, s->always_size * sizeof *s->always_table);
}
s->always_table[s->always_num++] = kind;
return PARSE_ERROR_NONE;
}
/**
* Read an object.
*/
static struct object *rd_item(void)
{
struct object *obj = object_new();
byte tmp8u;
u16b tmp16u;
byte effect;
size_t i;
char buf[128];
byte ver = 1;
rd_u16b(&tmp16u);
rd_byte(&ver);
if (tmp16u != 0xffff)
return NULL;
rd_u16b(&obj->oidx);
/* Location */
rd_byte(&obj->iy);
rd_byte(&obj->ix);
/* Type/Subtype */
rd_string(buf, sizeof(buf));
if (buf[0]) {
obj->tval = tval_find_idx(buf);
}
rd_string(buf, sizeof(buf));
if (buf[0]) {
obj->sval = lookup_sval(obj->tval, buf);
}
rd_s16b(&obj->pval);
rd_byte(&obj->number);
rd_s16b(&obj->weight);
rd_string(buf, sizeof(buf));
if (buf[0]) {
obj->artifact = lookup_artifact_name(buf);
if (!obj->artifact) {
note(format("Couldn't find artifact %s!", buf));
return NULL;
}
}
rd_string(buf, sizeof(buf));
if (buf[0]) {
obj->ego = lookup_ego_item(buf, obj->tval, obj->sval);
if (!obj->ego) {
note(format("Couldn't find ego item %s!", buf));
return NULL;
}
}
rd_byte(&effect);
rd_s16b(&obj->timeout);
rd_s16b(&obj->to_h);
rd_s16b(&obj->to_d);
rd_s16b(&obj->to_a);
rd_s16b(&obj->ac);
rd_byte(&obj->dd);
rd_byte(&obj->ds);
rd_byte(&obj->origin);
rd_byte(&obj->origin_depth);
rd_string(buf, sizeof(buf));
if (buf[0]) {
obj->origin_race = lookup_monster(buf);
}
rd_byte(&obj->notice);
for (i = 0; i < of_size; i++)
rd_byte(&obj->flags[i]);
for (i = 0; i < obj_mod_max; i++) {
rd_s16b(&obj->modifiers[i]);
}
/* Read brands */
rd_byte(&tmp8u);
if (tmp8u) {
obj->brands = mem_zalloc(z_info->brand_max * sizeof(bool));
for (i = 0; i < brand_max; i++) {
rd_byte(&tmp8u);
obj->brands[i] = tmp8u ? true : false;
}
}
/* Read slays */
rd_byte(&tmp8u);
if (tmp8u) {
obj->slays = mem_zalloc(z_info->slay_max * sizeof(bool));
for (i = 0; i < slay_max; i++) {
rd_byte(&tmp8u);
obj->slays[i] = tmp8u ? true : false;
}
}
/* Read curses */
rd_byte(&tmp8u);
if (tmp8u) {
obj->curses = mem_zalloc(z_info->curse_max * sizeof(struct curse_data));
for (i = 0; i < curse_max; i++) {
rd_byte(&tmp8u);
obj->curses[i].power = tmp8u;
rd_u16b(&tmp16u);
obj->curses[i].timeout = tmp16u;
}
}
for (i = 0; i < elem_max; i++) {
rd_s16b(&obj->el_info[i].res_level);
rd_byte(&obj->el_info[i].flags);
}
/* Monster holding object */
rd_s16b(&obj->held_m_idx);
rd_s16b(&obj->mimicking_m_idx);
/* Activation */
rd_u16b(&tmp16u);
if (tmp16u)
obj->activation = &activations[tmp16u];
rd_u16b(&tmp16u);
obj->time.base = tmp16u;
rd_u16b(&tmp16u);
obj->time.dice = tmp16u;
rd_u16b(&tmp16u);
obj->time.sides = tmp16u;
/* Save the inscription */
rd_string(buf, sizeof(buf));
if (buf[0]) obj->note = quark_add(buf);
/* Lookup item kind */
obj->kind = lookup_kind(obj->tval, obj->sval);
/* Check we have a kind */
if ((!obj->tval && !obj->sval) || !obj->kind) {
object_delete(&obj);
return NULL;
}
/* Set effect */
if (effect && obj->ego)
obj->effect = obj->ego->effect;
if (effect && !obj->effect)
obj->effect = obj->kind->effect;
/* Success */
return obj;
}