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_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_r_b(struct parser *p) { struct monster_race *r = parser_priv(p); int i; struct random dam; if (!r) return PARSE_ERROR_MISSING_RECORD_HEADER; for (i = 0; i < MONSTER_BLOW_MAX; i++) if (!r->blow[i].method) break; if (i == MONSTER_BLOW_MAX) return PARSE_ERROR_TOO_MANY_ENTRIES; r->blow[i].method = find_blow_method(parser_getsym(p, "method")); if (!r_info_blow_method[r->blow[i].method]) return PARSE_ERROR_UNRECOGNISED_BLOW; if (parser_hasval(p, "effect")) { r->blow[i].effect = find_blow_effect(parser_getsym(p, "effect")); if (!r_info_blow_effect[r->blow[i].effect]) return PARSE_ERROR_INVALID_EFFECT; } if (parser_hasval(p, "damage")) { dam = parser_getrand(p, "damage"); r->blow[i].d_dice = dam.dice; r->blow[i].d_side = dam.sides; } 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_prefs_m(struct parser *p) { int a, msg_index; const char *attr; const char *type; struct prefs_data *d = parser_priv(p); assert(d != NULL); if (d->bypass) return PARSE_ERROR_NONE; type = parser_getsym(p, "type"); attr = parser_getsym(p, "attr"); msg_index = message_lookup_by_name(type); if (msg_index < 0) return PARSE_ERROR_GENERIC; if (strlen(attr) > 1) a = color_text_to_attr(attr); else a = color_char_to_attr(attr[0]); if (a < 0) return PARSE_ERROR_INVALID_COLOR; message_color_define(msg_index, (byte)a); return PARSE_ERROR_NONE; }
static enum parser_error parse_prefs_gf(struct parser *p) { bool types[GF_MAX] = { 0 }; const char *direction; int motion; char *s, *t; size_t i; struct prefs_data *d = parser_priv(p); assert(d != NULL); if (d->bypass) return PARSE_ERROR_NONE; /* Parse the type, which is a | seperated list of GF_ constants */ s = string_make(parser_getsym(p, "type")); t = strtok(s, "| "); while (t) { if (streq(t, "*")) { memset(types, TRUE, sizeof types); } else { int idx = gf_name_to_idx(t); if (idx == -1) return PARSE_ERROR_INVALID_VALUE; types[idx] = TRUE; } t = strtok(NULL, "| "); } string_free(s); direction = parser_getsym(p, "direction"); if (streq(direction, "static")) motion = BOLT_NO_MOTION; else if (streq(direction, "0")) motion = BOLT_0; else if (streq(direction, "45")) motion = BOLT_45; else if (streq(direction, "90")) motion = BOLT_90; else if (streq(direction, "135")) motion = BOLT_135; else return PARSE_ERROR_INVALID_VALUE; for (i = 0; i < GF_MAX; i++) { if (!types[i]) continue; gf_to_attr[i][motion] = (byte) parser_getuint(p, "attr"); gf_to_char[i][motion] = (wchar_t) parser_getuint(p, "char"); } return PARSE_ERROR_NONE; }
static enum parser_error helper_sym1(struct parser *p) { const char *s = parser_getsym(p, "foo"); const char *t = parser_getsym(p, "baz"); int *wasok = parser_priv(p); if (!s || !t || strcmp(s, "bar") || strcmp(t, "quxx")) return PARSE_ERROR_GENERIC; *wasok = 1; return PARSE_ERROR_NONE; }
static enum parser_error helper_opt0(struct parser *p) { const char *s0 = parser_getsym(p, "s0"); const char *s1 = parser_hasval(p, "s1") ? parser_getsym(p, "s1") : NULL; int *wasok = parser_priv(p); if (!s0 || strcmp(s0, "foo")) return PARSE_ERROR_GENERIC; if (s1 && !strcmp(s1, "bar")) *wasok = 2; else *wasok = 1; return PARSE_ERROR_NONE; }
static enum parser_error parse_prefs_m(struct parser *p) { int a, type; const char *attr; struct prefs_data *d = parser_priv(p); assert(d != NULL); if (d->bypass) return PARSE_ERROR_NONE; type = parser_getint(p, "type"); attr = parser_getsym(p, "attr"); if (strlen(attr) > 1) a = color_text_to_attr(attr); else a = color_char_to_attr(attr[0]); if (a < 0) return PARSE_ERROR_INVALID_COLOR; message_color_define((u16b) type, (byte) a); 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_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_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; }
static enum parser_error parse_summon_message_type(struct parser *p) { struct summon *s = parser_priv(p); int msg_index; const char *type; assert(s); type = parser_getsym(p, "type"); msg_index = message_lookup_by_name(type); if (msg_index < 0) return PARSE_ERROR_INVALID_MESSAGE; s->message_type = msg_index; return PARSE_ERROR_NONE; }
static enum parser_error parse_summon_race_flag(struct parser *p) { struct summon *s = parser_priv(p); int flag; assert(s); flag = lookup_flag(mon_race_flags, parser_getsym(p, "flag")); if (flag == FLAG_END) { return PARSE_ERROR_INVALID_FLAG; } else { s->race_flag = flag; } return PARSE_ERROR_NONE; }
static enum parser_error parse_summon_base(struct parser *p) { struct summon *s = parser_priv(p); struct monster_base *base; struct monster_base_list *b = mem_zalloc(sizeof(*b)); assert(s); base = lookup_monster_base(parser_getsym(p, "base")); if (base == NULL) { mem_free(b); return PARSE_ERROR_INVALID_MONSTER_BASE; } b->base = base; b->next = s->bases; s->bases = b; return PARSE_ERROR_NONE; }
static enum parser_error parse_r_t(struct parser *p) { struct monster_race *r = parser_priv(p); r->base = lookup_monster_base(parser_getsym(p, "base")); if (r->base == NULL) /* Todo: make new error for this */ return PARSE_ERROR_UNRECOGNISED_TVAL; /* The template sets the default display character */ r->d_char = r->base->d_char; /* Give the monster its default flags */ rf_union(r->flags, r->base->flags); return PARSE_ERROR_NONE; }
static enum parser_error parse_r_c(struct parser *p) { struct monster_race *r = parser_priv(p); const char *color; int attr; if (!r) return PARSE_ERROR_MISSING_RECORD_HEADER; color = parser_getsym(p, "color"); if (strlen(color) > 1) attr = color_text_to_attr(color); else attr = color_char_to_attr(color[0]); if (attr < 0) return PARSE_ERROR_INVALID_COLOR; r->d_attr = attr; return PARSE_ERROR_NONE; }
static enum parser_error parse_prefs_f(struct parser *p) { int idx; feature_type *feature; const char *lighting; int light_idx; struct prefs_data *d = parser_priv(p); assert(d != NULL); if (d->bypass) return PARSE_ERROR_NONE; idx = parser_getuint(p, "idx"); if (idx >= z_info->f_max) return PARSE_ERROR_OUT_OF_BOUNDS; lighting = parser_getsym(p, "lighting"); if (streq(lighting, "torch")) light_idx = FEAT_LIGHTING_TORCH; else if (streq(lighting, "los")) light_idx = FEAT_LIGHTING_LOS; else if (streq(lighting, "lit")) light_idx = FEAT_LIGHTING_LIT; else if (streq(lighting, "dark")) light_idx = FEAT_LIGHTING_DARK; else if (streq(lighting, "all")) light_idx = FEAT_LIGHTING_MAX; else return PARSE_ERROR_GENERIC; /* xxx fixme */ if (light_idx < FEAT_LIGHTING_MAX) { feature = &f_info[idx]; feature->x_attr[light_idx] = (byte) parser_getint(p, "attr"); feature->x_char[light_idx] = (wchar_t) parser_getint(p, "char"); } else { for (light_idx = 0; light_idx < FEAT_LIGHTING_MAX; light_idx++) { feature = &f_info[idx]; feature->x_attr[light_idx] = (byte) parser_getint(p, "attr"); feature->x_char[light_idx] = (wchar_t) parser_getint(p, "char"); } } return PARSE_ERROR_NONE; }
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; }
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; }
enum parser_error parse_prefs_sound(struct parser *p) { int msg_index; const char *type; const char *sounds_local; struct prefs_data *d = parser_priv(p); assert(d != NULL); if (d->bypass) return PARSE_ERROR_NONE; type = parser_getsym(p, "type"); sounds_local = parser_getstr(p, "sounds"); msg_index = message_lookup_by_name(type); if (msg_index < 0) return PARSE_ERROR_INVALID_MESSAGE; message_sound_define(msg_index, sounds_local); return PARSE_ERROR_NONE; }
static enum parser_error parse_profile_room(struct parser *p) { struct cave_profile *c = parser_priv(p); struct room_profile *r = c->room_profiles; size_t i; if (!c) return PARSE_ERROR_MISSING_RECORD_HEADER; /* Go to the last valid room profile, then allocate a new one */ if (!r) { c->room_profiles = mem_zalloc(sizeof(struct room_profile)); r = c->room_profiles; } else { while (r->next) r = r->next; r->next = mem_zalloc(sizeof(struct room_profile)); r = r->next; } /* Now read the data */ r->name = string_make(parser_getsym(p, "name")); for (i = 0; i < N_ELEMENTS(room_builders); i++) if (streq(r->name, room_builders[i].name)) break; if (i == N_ELEMENTS(room_builders)) return PARSE_ERROR_NO_ROOM_FOUND; r->builder = room_builders[i].builder; r->height = parser_getint(p, "height"); r->width = parser_getint(p, "width"); r->level = parser_getint(p, "level"); r->pit = (parser_getint(p, "pit") == 1); r->rarity = parser_getint(p, "rarity"); r->cutoff = parser_getint(p, "cutoff"); return PARSE_ERROR_NONE; }