static int
change_inv_order(const char *op)
{
int oc_sym, num;
char buf[MAXOCLASSES];
const char *sp;
num = 0;
for (sp = op; *sp; sp++) {
oc_sym = def_char_to_objclass(*sp);
/* reject bad or duplicate entries */
if (oc_sym == MAXOCLASSES || oc_sym == RANDOM_CLASS ||
oc_sym == ILLOBJ_CLASS || !strchr(flags.inv_order, oc_sym) ||
strchr(sp + 1, *sp))
return 0;
/* retain good ones */
buf[num++] = (char)oc_sym;
}
buf[num] = '\0';
/* fill in any omitted classes, using previous ordering */
for (sp = flags.inv_order; *sp; sp++)
if (!strchr(buf, *sp)) {
buf[num++] = *sp;
buf[num] = '\0'; /* explicitly terminate for next strchr() */
}
strcpy(flags.inv_order, buf);
return 1;
}
/*
* entry is the position of the tile within the monsters/objects/other set
*/
const char *
tilename(int set, int entry)
{
int i, j, condnum, tilenum;
static char buf[BUFSZ];
/* Note: these initializers don't do anything except guarantee that
we're linked properly.
*/
monst_init();
objects_init();
(void) def_char_to_objclass(']');
condnum = tilenum = 0;
for (i = 0; i < NUMMONS; i++) {
if (set == MON_GLYPH && tilenum == entry)
return mons[i].mname;
tilenum++;
while (conditionals[condnum].sequence == MON_GLYPH &&
conditionals[condnum].predecessor == i) {
if (set == MON_GLYPH && tilenum == entry)
return conditionals[condnum].name;
condnum++;
tilenum++;
}
}
if (set == MON_GLYPH && tilenum == entry)
return "invisible monster";
tilenum = 0; /* set-relative number */
for (i = 0; i < NUM_OBJECTS; i++) {
/* prefer to give the description - that's all the tile's
* appearance should reveal */
if (set == OBJ_GLYPH && tilenum == entry) {
if ( !obj_descr[i].oc_descr )
return obj_descr[i].oc_name;
if ( !obj_descr[i].oc_name )
return obj_descr[i].oc_descr;
Sprintf(buf, "%s / %s",
obj_descr[i].oc_descr,
obj_descr[i].oc_name);
return buf;
}
tilenum++;
while (conditionals[condnum].sequence == OBJ_GLYPH &&
conditionals[condnum].predecessor == i) {
if (set == OBJ_GLYPH && tilenum == entry)
return conditionals[condnum].name;
condnum++;
tilenum++;
}
}
tilenum = 0; /* set-relative number */
for (i = 0; i < (MAXPCHARS - MAXEXPCHARS); i++) {
if (set == OTH_GLYPH && tilenum == entry) {
if (*defsyms[i].explanation)
return defsyms[i].explanation;
else {
/* if SINKS are turned off, this
* string won't be there (and can't be there
* to prevent symbol-identification and
* special-level mimic appearances from
* thinking the items exist)
*/
switch (i) {
case S_sink:
Sprintf(buf, "sink");
break;
default:
Sprintf(buf, "cmap %d", tilenum);
break;
}
return buf;
}
}
tilenum++;
while (conditionals[condnum].sequence == OTH_GLYPH &&
conditionals[condnum].predecessor == i) {
if (set == OTH_GLYPH && tilenum == entry)
return conditionals[condnum].name;
condnum++;
tilenum++;
}
}
/* explosions */
tilenum = MAXPCHARS - MAXEXPCHARS;
i = entry - tilenum;
if (i < (MAXEXPCHARS * EXPL_MAX)) {
if (set == OTH_GLYPH) {
static char *explosion_types[] = { /* hack.h */
"dark", "noxious", "muddy", "wet",
"magical", "fiery", "frosty"
};
Sprintf(buf, "explosion %s %d",
explosion_types[i / MAXEXPCHARS], i % MAXEXPCHARS);
return buf;
}
}
tilenum += (MAXEXPCHARS * EXPL_MAX);
i = entry - tilenum;
if (i < (NUM_ZAP << 2)) {
if (set == OTH_GLYPH) {
Sprintf(buf, "zap %d %d", i/4, i%4);
return buf;
}
}
tilenum += (NUM_ZAP << 2);
i = entry - tilenum;
if (i < WARNCOUNT) {
if (set == OTH_GLYPH) {
Sprintf(buf, "warning %d", i);
return buf;
}
}
tilenum += WARNCOUNT;
for (i = 0; i < SIZE(substitutes); i++) {
j = entry - tilenum;
if (j <= substitutes[i].last_glyph - substitutes[i].first_glyph) {
if (set == OTH_GLYPH) {
Sprintf(buf, "sub %s %d", substitutes[i].sub_name, j);
return buf;
}
}
tilenum += substitutes[i].last_glyph
- substitutes[i].first_glyph + 1;
}
Sprintf(buf, "unknown %d %d", set, entry);
return buf;
}
