Source:NetHack 3.6.0/src/botl.c

Below is the full text to botl.c from the source code of NetHack 3.6.0. To link to a particular line, write [[Source:NetHack 3.6.0/src/botl.c#line123]], for example.

The NetHack General Public License applies to screenshots, source code and other content from NetHack.

This content was modified from the original NetHack source code distribution (by splitting up NetHack content between wiki pages, and possibly further editing). See the page history for a list of who changed it, and on what dates.

Top of file

 /* NetHack 3.6	botl.c	$NHDT-Date: 1447978683 2015/11/20 00:18:03 $  $NHDT-Branch: master $:$NHDT-Revision: 1.69 $ */
 /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
 /* NetHack may be freely redistributed.  See license for details. */
 
 #include "hack.h"
 #include <limits.h>
 
 extern const char *hu_stat[]; /* defined in eat.c */
 
 const char *const enc_stat[] = { "",         "Burdened",  "Stressed",
                                  "Strained", "Overtaxed", "Overloaded" };
 
 STATIC_OVL NEARDATA int mrank_sz = 0; /* loaded by max_rank_sz (from u_init) */
 STATIC_DCL const char *NDECL(rank);
 

Status not via windowport

 #ifndef STATUS_VIA_WINDOWPORT
 
 STATIC_DCL void NDECL(bot1);
 STATIC_DCL void NDECL(bot2);
 

bot1

 STATIC_OVL void
 bot1()
 {
     char newbot1[MAXCO];
     register char *nb;
     register int i, j;
 
     Strcpy(newbot1, plname);
     if ('a' <= newbot1[0] && newbot1[0] <= 'z')
         newbot1[0] += 'A' - 'a';
     newbot1[10] = 0;
     Sprintf(nb = eos(newbot1), " the ");
 
     if (Upolyd) {
         char mbot[BUFSZ];
         int k = 0;
 
         Strcpy(mbot, mons[u.umonnum].mname);
         while (mbot[k] != 0) {
             if ((k == 0 || (k > 0 && mbot[k - 1] == ' ')) && 'a' <= mbot[k]
                 && mbot[k] <= 'z')
                 mbot[k] += 'A' - 'a';
             k++;
         }
         Strcpy(nb = eos(nb), mbot);
     } else
         Strcpy(nb = eos(nb), rank());
 
     Sprintf(nb = eos(nb), "  ");
     i = mrank_sz + 15;
     j = (int) ((nb + 2) - newbot1); /* strlen(newbot1) but less computation */
     if ((i - j) > 0)
         Sprintf(nb = eos(nb), "%*s", i - j, " "); /* pad with spaces */
     if (ACURR(A_STR) > 18) {
         if (ACURR(A_STR) > STR18(100))
             Sprintf(nb = eos(nb), "St:%2d ", ACURR(A_STR) - 100);
         else if (ACURR(A_STR) < STR18(100))
             Sprintf(nb = eos(nb), "St:18/%02d ", ACURR(A_STR) - 18);
         else
             Sprintf(nb = eos(nb), "St:18/** ");
     } else
         Sprintf(nb = eos(nb), "St:%-1d ", ACURR(A_STR));
     Sprintf(nb = eos(nb), "Dx:%-1d Co:%-1d In:%-1d Wi:%-1d Ch:%-1d",
             ACURR(A_DEX), ACURR(A_CON), ACURR(A_INT), ACURR(A_WIS),
             ACURR(A_CHA));
     Sprintf(nb = eos(nb),
             (u.ualign.type == A_CHAOTIC)
                 ? "  Chaotic"
                 : (u.ualign.type == A_NEUTRAL) ? "  Neutral" : "  Lawful");
 #ifdef SCORE_ON_BOTL
     if (flags.showscore)
         Sprintf(nb = eos(nb), " S:%ld", botl_score());
 #endif
     curs(WIN_STATUS, 1, 0);
     putstr(WIN_STATUS, 0, newbot1);
 }
 

bot2

 STATIC_OVL void
 bot2()
 {
     char newbot2[MAXCO];
     register char *nb;
     int hp, hpmax;
     int cap = near_capacity();
 
     hp = Upolyd ? u.mh : u.uhp;
     hpmax = Upolyd ? u.mhmax : u.uhpmax;
 
     if (hp < 0)
         hp = 0;
     (void) describe_level(newbot2);
     Sprintf(nb = eos(newbot2), "%s:%-2ld HP:%d(%d) Pw:%d(%d) AC:%-2d",
             encglyph(objnum_to_glyph(GOLD_PIECE)), money_cnt(invent), hp,
             hpmax, u.uen, u.uenmax, u.uac);
 
     if (Upolyd)
         Sprintf(nb = eos(nb), " HD:%d", mons[u.umonnum].mlevel);
     else if (flags.showexp)
         Sprintf(nb = eos(nb), " Xp:%u/%-1ld", u.ulevel, u.uexp);
     else
         Sprintf(nb = eos(nb), " Exp:%u", u.ulevel);
 
     if (flags.time)
         Sprintf(nb = eos(nb), " T:%ld", moves);
     if (strcmp(hu_stat[u.uhs], "        ")) {
         Sprintf(nb = eos(nb), " ");
         Strcat(newbot2, hu_stat[u.uhs]);
     }
     if (Confusion)
         Sprintf(nb = eos(nb), " Conf");
     if (Sick) {
         if (u.usick_type & SICK_VOMITABLE)
             Sprintf(nb = eos(nb), " FoodPois");
         if (u.usick_type & SICK_NONVOMITABLE)
             Sprintf(nb = eos(nb), " Ill");
     }
     if (Blind)
         Sprintf(nb = eos(nb), " Blind");
     if (Stunned)
         Sprintf(nb = eos(nb), " Stun");
     if (Hallucination)
         Sprintf(nb = eos(nb), " Hallu");
     if (Slimed)
         Sprintf(nb = eos(nb), " Slime");
     if (cap > UNENCUMBERED)
         Sprintf(nb = eos(nb), " %s", enc_stat[cap]);
     curs(WIN_STATUS, 1, 1);
     putmixed(WIN_STATUS, 0, newbot2);
 }
 

bot

 void
 bot()
 {
     if (youmonst.data) {
         bot1();
         bot2();
     }
     context.botl = context.botlx = 0;
 }
 
 #endif /* !STATUS_VIA_WINDOWPORT */
 

Status via all outputs

xlev_to_rank

 /* convert experience level (1..30) to rank index (0..8) */
 int
 xlev_to_rank(xlev)
 int xlev;
 {
     return (xlev <= 2) ? 0 : (xlev <= 30) ? ((xlev + 2) / 4) : 8;
 }
 

rank_to_xlev

 #if 0 /* not currently needed */
 /* convert rank index (0..8) to experience level (1..30) */
 int
 rank_to_xlev(rank)
 int rank;
 {
     return (rank <= 0) ? 1 : (rank <= 8) ? ((rank * 4) - 2) : 30;
 }
 #endif
 

rank_of

 const char *
 rank_of(lev, monnum, female)
 int lev;
 short monnum;
 boolean female;
 {
     register const struct Role *role;
     register int i;
 
     /* Find the role */
     for (role = roles; role->name.m; role++)
         if (monnum == role->malenum || monnum == role->femalenum)
             break;
     if (!role->name.m)
         role = &urole;
 
     /* Find the rank */
     for (i = xlev_to_rank((int) lev); i >= 0; i--) {
         if (female && role->rank[i].f)
             return role->rank[i].f;
         if (role->rank[i].m)
             return role->rank[i].m;
     }
 
     /* Try the role name, instead */
     if (female && role->name.f)
         return role->name.f;
     else if (role->name.m)
         return role->name.m;
     return "Player";
 }
 

rank

 STATIC_OVL const char *
 rank()
 {
     return rank_of(u.ulevel, Role_switch, flags.female);
 }
 

title_to_mon

 int
 title_to_mon(str, rank_indx, title_length)
 const char *str;
 int *rank_indx, *title_length;
 {
     register int i, j;
 
     /* Loop through each of the roles */
     for (i = 0; roles[i].name.m; i++)
         for (j = 0; j < 9; j++) {
             if (roles[i].rank[j].m
                 && !strncmpi(str, roles[i].rank[j].m,
                              strlen(roles[i].rank[j].m))) {
                 if (rank_indx)
                     *rank_indx = j;
                 if (title_length)
                     *title_length = strlen(roles[i].rank[j].m);
                 return roles[i].malenum;
             }
             if (roles[i].rank[j].f
                 && !strncmpi(str, roles[i].rank[j].f,
                              strlen(roles[i].rank[j].f))) {
                 if (rank_indx)
                     *rank_indx = j;
                 if (title_length)
                     *title_length = strlen(roles[i].rank[j].f);
                 return (roles[i].femalenum != NON_PM) ? roles[i].femalenum
                                                       : roles[i].malenum;
             }
         }
     return NON_PM;
 }
 

max_rank_sz

 void
 max_rank_sz()
 {
     register int i, r, maxr = 0;
     for (i = 0; i < 9; i++) {
         if (urole.rank[i].m && (r = strlen(urole.rank[i].m)) > maxr)
             maxr = r;
         if (urole.rank[i].f && (r = strlen(urole.rank[i].f)) > maxr)
             maxr = r;
     }
     mrank_sz = maxr;
     return;
 }
 

botl_score

 #ifdef SCORE_ON_BOTL
 long
 botl_score()
 {
     long deepest = deepest_lev_reached(FALSE);
     long utotal;
 
     utotal = money_cnt(invent) + hidden_gold();
     if ((utotal -= u.umoney0) < 0L)
         utotal = 0L;
     utotal += u.urexp + (50 * (deepest - 1))
           + (deepest > 30 ? 10000 : deepest > 20 ? 1000 * (deepest - 20) : 0);
     if (utotal < u.urexp)
         utotal = LONG_MAX; /* wrap around */
     return utotal;
 }
 #endif /* SCORE_ON_BOTL */
 

describe_level

 /* provide the name of the current level for display by various ports */
 int
 describe_level(buf)
 char *buf;
 {
     int ret = 1;
 
     /* TODO:    Add in dungeon name */
     if (Is_knox(&u.uz))
         Sprintf(buf, "%s ", dungeons[u.uz.dnum].dname);
     else if (In_quest(&u.uz))
         Sprintf(buf, "Home %d ", dunlev(&u.uz));
     else if (In_endgame(&u.uz))
         Sprintf(buf, Is_astralevel(&u.uz) ? "Astral Plane " : "End Game ");
     else {
         /* ports with more room may expand this one */
         Sprintf(buf, "Dlvl:%-2d ", depth(&u.uz));
         ret = 0;
     }
     return ret;
 }
 

Status via windowport

 #ifdef STATUS_VIA_WINDOWPORT
 /* =======================================================================*/
 
 /* structure that tracks the status details in the core */
 struct istat_s {
     long time;
     unsigned anytype;
     anything a;
     char *val;
     int valwidth;
     enum statusfields idxmax;
     enum statusfields fld;
 };
 
 
 STATIC_DCL void NDECL(init_blstats);
 STATIC_DCL char *FDECL(anything_to_s, (char *, anything *, int));
 STATIC_DCL void FDECL(s_to_anything, (anything *, char *, int));
 STATIC_OVL int FDECL(percentage, (struct istat_s *, struct istat_s *));
 STATIC_OVL int FDECL(compare_blstats, (struct istat_s *, struct istat_s *));
 
 #ifdef STATUS_HILITES
 STATIC_DCL boolean FDECL(assign_hilite, (char *, char *, char *, char *,
                                          BOOLEAN_P));
 STATIC_DCL const char *FDECL(clridx_to_s, (char *, int));
 #endif
 
 /* If entries are added to this, botl.h will require updating too */
 STATIC_DCL struct istat_s initblstats[MAXBLSTATS] = {
     { 0L, ANY_STR,  { (genericptr_t) 0 }, (char *) 0, 80,  0, BL_TITLE},
     { 0L, ANY_INT,  { (genericptr_t) 0 }, (char *) 0, 10,  0, BL_STR},
     { 0L, ANY_INT,  { (genericptr_t) 0 }, (char *) 0, 10,  0, BL_DX},
     { 0L, ANY_INT,  { (genericptr_t) 0 }, (char *) 0, 10,  0, BL_CO},
     { 0L, ANY_INT,  { (genericptr_t) 0 }, (char *) 0, 10,  0, BL_IN},
     { 0L, ANY_INT,  { (genericptr_t) 0 }, (char *) 0, 10,  0, BL_WI},
     { 0L, ANY_INT,  { (genericptr_t) 0 }, (char *) 0, 10,  0, BL_CH},
     { 0L, ANY_STR,  { (genericptr_t) 0 }, (char *) 0, 40,  0, BL_ALIGN},
     { 0L, ANY_LONG, { (genericptr_t) 0 }, (char *) 0, 20,  0, BL_SCORE},
     { 0L, ANY_LONG, { (genericptr_t) 0 }, (char *) 0, 20,  0, BL_CAP},
     { 0L, ANY_LONG, { (genericptr_t) 0 }, (char *) 0, 30,  0, BL_GOLD},
     { 0L, ANY_INT,  { (genericptr_t) 0 }, (char *) 0, 10,  BL_ENEMAX, BL_ENE},
     { 0L, ANY_INT,  { (genericptr_t) 0 }, (char *) 0, 10,  0, BL_ENEMAX},
     { 0L, ANY_LONG, { (genericptr_t) 0 }, (char *) 0, 10,  0, BL_XP},
     { 0L, ANY_INT,  { (genericptr_t) 0 }, (char *) 0, 10,  0, BL_AC},
     { 0L, ANY_INT,  { (genericptr_t) 0 }, (char *) 0, 10,  0, BL_HD},
     { 0L, ANY_INT,  { (genericptr_t) 0 }, (char *) 0, 20,  0, BL_TIME},
     { 0L, ANY_UINT, { (genericptr_t) 0 }, (char *) 0, 40,  0, BL_HUNGER},
     { 0L, ANY_INT,  { (genericptr_t) 0 }, (char *) 0, 10,  BL_HPMAX, BL_HP},
     { 0L, ANY_INT,  { (genericptr_t) 0 }, (char *) 0, 10,  0, BL_HPMAX},
     { 0L, ANY_STR,  { (genericptr_t) 0 }, (char *) 0, 80,  0, BL_LEVELDESC},
     { 0L, ANY_LONG, { (genericptr_t) 0 }, (char *) 0, 20,  0, BL_EXP},
     { 0L, ANY_MASK32,
                     { (genericptr_t) 0 }, (char *) 0,  0,  0, BL_CONDITION}
 };
 
 static struct fieldid_t {
         const char *fieldname;
         enum statusfields fldid;
 } fieldids[] = {
         {"title",               BL_TITLE},
         {"strength",            BL_STR},
         {"dexterity",           BL_DX},
         {"constitution",        BL_CO},
         {"intelligence",        BL_IN},
         {"wisdom",              BL_WI},
         {"charisma",            BL_CH},
         {"alignment",           BL_ALIGN},
         {"score",               BL_SCORE},
         {"carrying-capacity",   BL_CAP},
         {"gold",                BL_GOLD},
         {"power",               BL_ENE},
         {"power-max",           BL_ENEMAX},
         {"experience-level",    BL_XP},
         {"armor-class",         BL_AC},
         {"HD",                  BL_HD},
         {"time",                BL_TIME},
         {"hunger",              BL_HUNGER},
         {"hitpoints",           BL_HP},
         {"hitpoints-max",       BL_HPMAX},
         {"dungeon-level",       BL_LEVELDESC},
         {"experience",          BL_EXP},
         {"condition",           BL_CONDITION},
 };
 
 struct istat_s blstats[2][MAXBLSTATS];
 static boolean blinit = FALSE, update_all = FALSE;
 

bot

 void
 bot()
 {
     char buf[BUFSZ];
     register char *nb;
     static int idx = 0, idx_p, idxmax;
     boolean updated = FALSE;
     unsigned anytype;
     int i, pc, chg, cap;
     struct istat_s *curr, *prev;
     boolean valset[MAXBLSTATS], chgval = FALSE;
 
     if (!blinit)
         panic("bot before init.");
     if (!youmonst.data) {
         context.botl = context.botlx = 0;
         update_all = FALSE;
         return;
     }
 
     cap = near_capacity();
     idx_p = idx;
     idx = 1 - idx; /* 0 -> 1, 1 -> 0 */
 
     /* clear the "value set" indicators */
     (void) memset((genericptr_t) valset, 0, MAXBLSTATS * sizeof(boolean));
 
     /*
      *  Player name and title.
      */
     buf[0] = '\0';
     Strcpy(buf, plname);
     if ('a' <= buf[0] && buf[0] <= 'z')
         buf[0] += 'A' - 'a';
     buf[10] = 0;
     Sprintf(nb = eos(buf), " the ");
     if (Upolyd) {
         char mbot[BUFSZ];
         int k = 0;
 
         Strcpy(mbot, mons[u.umonnum].mname);
         while (mbot[k] != 0) {
             if ((k == 0 || (k > 0 && mbot[k - 1] == ' ')) && 'a' <= mbot[k]
                 && mbot[k] <= 'z')
                 mbot[k] += 'A' - 'a';
             k++;
         }
         Sprintf1(nb = eos(nb), mbot);
     } else
         Sprintf1(nb = eos(nb), rank());
     Sprintf(blstats[idx][BL_TITLE].val, "%-29s", buf);
     valset[BL_TITLE] = TRUE; /* indicate val already set */
 
     /* Strength */
 
     buf[0] = '\0';
     blstats[idx][BL_STR].a.a_int = ACURR(A_STR);
     if (ACURR(A_STR) > 18) {
         if (ACURR(A_STR) > STR18(100))
             Sprintf(buf, "%2d", ACURR(A_STR) - 100);
         else if (ACURR(A_STR) < STR18(100))
             Sprintf(buf, "18/%02d", ACURR(A_STR) - 18);
         else
             Sprintf(buf, "18/**");
     } else
         Sprintf(buf, "%-1d", ACURR(A_STR));
     Strcpy(blstats[idx][BL_STR].val, buf);
     valset[BL_STR] = TRUE; /* indicate val already set */
 
     /*  Dexterity, constitution, intelligence, wisdom, charisma. */
 
     blstats[idx][BL_DX].a.a_int = ACURR(A_DEX);
     blstats[idx][BL_CO].a.a_int = ACURR(A_CON);
     blstats[idx][BL_IN].a.a_int = ACURR(A_INT);
     blstats[idx][BL_WI].a.a_int = ACURR(A_WIS);
     blstats[idx][BL_CH].a.a_int = ACURR(A_CHA);
 
     /* Alignment */
 
     Strcpy(blstats[idx][BL_ALIGN].val,
            (u.ualign.type == A_CHAOTIC)
                ? "Chaotic"
                : (u.ualign.type == A_NEUTRAL) ? "Neutral" : "Lawful");
 
     /* Score */
 
     blstats[idx][BL_SCORE].a.a_long =
 #ifdef SCORE_ON_BOTL
         botl_score();
 #else
         0;
 #endif
     /*  Hit points  */
 
     blstats[idx][BL_HP].a.a_int = Upolyd ? u.mh : u.uhp;
     blstats[idx][BL_HPMAX].a.a_int = Upolyd ? u.mhmax : u.uhpmax;
     if (blstats[idx][BL_HP].a.a_int < 0)
         blstats[idx][BL_HP].a.a_int = 0;
 
     /*  Dungeon level. */
 
     (void) describe_level(blstats[idx][BL_LEVELDESC].val);
     valset[BL_LEVELDESC] = TRUE; /* indicate val already set */
 
     /* Gold */
 
     blstats[idx][BL_GOLD].a.a_long = money_cnt(invent);
     /*
      * The tty port needs to display the current symbol for gold
      * as a field header, so to accommodate that we pass gold with
      * that already included. If a window port needs to use the text
      * gold amount without the leading "$:" the port will have to
      * add 2 to the value pointer it was passed in status_update()
      * for the BL_GOLD case.
      *
      * Another quirk of BL_GOLD is that the field display may have
      * changed if a new symbol set was loaded, or we entered or left
      * the rogue level.
      */
 
     Sprintf(blstats[idx][BL_GOLD].val, "%s:%ld",
             encglyph(objnum_to_glyph(GOLD_PIECE)),
             blstats[idx][BL_GOLD].a.a_long);
     valset[BL_GOLD] = TRUE; /* indicate val already set */
 
     /* Power (magical energy) */
 
     blstats[idx][BL_ENE].a.a_int = u.uen;
     blstats[idx][BL_ENEMAX].a.a_int = u.uenmax;
 
     /* Armor class */
 
     blstats[idx][BL_AC].a.a_int = u.uac;
 
     /* Monster level (if Upolyd) */
 
     if (Upolyd)
         blstats[idx][BL_HD].a.a_int = mons[u.umonnum].mlevel;
     else
         blstats[idx][BL_HD].a.a_int = 0;
 
     /* Experience */
 
     blstats[idx][BL_XP].a.a_int = u.ulevel;
     blstats[idx][BL_EXP].a.a_int = u.uexp;
 
     /* Time (moves) */
 
     blstats[idx][BL_TIME].a.a_long = moves;
 
     /* Hunger */
 
     blstats[idx][BL_HUNGER].a.a_uint = u.uhs;
     *(blstats[idx][BL_HUNGER].val) = '\0';
     if (strcmp(hu_stat[u.uhs], "        ") != 0)
         Strcpy(blstats[idx][BL_HUNGER].val, hu_stat[u.uhs]);
     valset[BL_HUNGER] = TRUE;
 
     /* Carrying capacity */
 
     *(blstats[idx][BL_CAP].val) = '\0';
     blstats[idx][BL_CAP].a.a_int = cap;
     if (cap > UNENCUMBERED)
         Strcpy(blstats[idx][BL_CAP].val, enc_stat[cap]);
     valset[BL_CAP] = TRUE;
 
     /* Conditions */
 
     if (Blind)
         blstats[idx][BL_CONDITION].a.a_ulong |= BL_MASK_BLIND;
     else
         blstats[idx][BL_CONDITION].a.a_ulong &= ~BL_MASK_BLIND;
 
     if (Confusion)
         blstats[idx][BL_CONDITION].a.a_ulong |= BL_MASK_CONF;
     else
         blstats[idx][BL_CONDITION].a.a_ulong &= ~BL_MASK_CONF;
 
     if (Sick && u.usick_type & SICK_VOMITABLE)
         blstats[idx][BL_CONDITION].a.a_ulong |= BL_MASK_FOODPOIS;
     else
         blstats[idx][BL_CONDITION].a.a_ulong &= ~BL_MASK_FOODPOIS;
 
     if (Sick && u.usick_type & SICK_NONVOMITABLE)
         blstats[idx][BL_CONDITION].a.a_ulong |= BL_MASK_ILL;
     else
         blstats[idx][BL_CONDITION].a.a_ulong &= ~BL_MASK_ILL;
 
     if (Hallucination)
         blstats[idx][BL_CONDITION].a.a_ulong |= BL_MASK_HALLU;
     else
         blstats[idx][BL_CONDITION].a.a_ulong &= ~BL_MASK_HALLU;
 
     if (Stunned)
         blstats[idx][BL_CONDITION].a.a_ulong |= BL_MASK_STUNNED;
     else
         blstats[idx][BL_CONDITION].a.a_ulong &= ~BL_MASK_STUNNED;
 
     if (Slimed)
         blstats[idx][BL_CONDITION].a.a_ulong |= BL_MASK_SLIMED;
     else
         blstats[idx][BL_CONDITION].a.a_ulong &= ~BL_MASK_SLIMED;
 
     /*
      *  Now pass the changed values to window port.
      */
     for (i = 0; i < MAXBLSTATS; i++) {
         if (((i == BL_SCORE) && !flags.showscore)
             || ((i == BL_EXP) && !flags.showexp)
             || ((i == BL_TIME) && !flags.time)
             || ((i == BL_HD) && !Upolyd)
             || ((i == BL_XP || i == BL_EXP) && Upolyd))
             continue;
         anytype = blstats[idx][i].anytype;
         curr = &blstats[idx][i];
         prev = &blstats[idx_p][i];
         chg = 0;
         if (update_all || ((chg = compare_blstats(prev, curr)) != 0)
             || ((chgval = (valset[i] && strcmp(blstats[idx][i].val,
                                                blstats[idx_p][i].val)))
                 != 0)) {
             idxmax = blstats[idx][i].idxmax;
             pc = (idxmax) ? percentage(curr, &blstats[idx][idxmax]) : 0;
             if (!valset[i])
                 (void) anything_to_s(curr->val, &curr->a, anytype);
             if (anytype != ANY_MASK32) {
                 status_update(i, (genericptr_t) curr->val,
                               valset[i] ? chgval : chg, pc);
             } else {
                 status_update(i,
                               /* send pointer to mask */
                               (genericptr_t) &curr->a.a_ulong, chg, 0);
             }
             updated = TRUE;
         }
     }
     /*
      * It is possible to get here, with nothing having been pushed
      * to the window port, when none of the info has changed. In that
      * case, we need to force a call to status_update() when
      * context.botlx is set. The tty port in particular has a problem
      * if that isn't done, since it sets context.botlx when a menu or
      * text display obliterates the status line.
      *
      * To work around it, we call status_update() with fictitious
      * index of BL_FLUSH (-1).
      */
     if (context.botlx && !updated)
         status_update(BL_FLUSH, (genericptr_t) 0, 0, 0);
 
     context.botl = context.botlx = 0;
     update_all = FALSE;
 }
 

status_initialize

 void
 status_initialize(reassessment)
 boolean
     reassessment; /* TRUE = just reassess fields w/o other initialization*/
 {
     int i;
     const char *fieldfmt = (const char *)0;
     const char *fieldname = (const char *)0;
 
     if (!reassessment) {
         init_blstats();
         (*windowprocs.win_status_init)();
         blinit = TRUE;
 #ifdef STATUS_HILITES
         status_notify_windowport(TRUE);
 #endif
     }
     for (i = 0; i < MAXBLSTATS; ++i) {
         enum statusfields fld = initblstats[i].fld;
 
         switch (fld) {
         case BL_TITLE:
             fieldfmt = "%s";
             fieldname = "title";
             status_enablefield(fld, fieldname, fieldfmt, TRUE);
             break;
         case BL_STR:
             fieldfmt = " St:%s";
             fieldname = "strength";
             status_enablefield(fld, fieldname, fieldfmt, TRUE);
             break;
         case BL_DX:
             fieldfmt = " Dx:%s";
             fieldname = "dexterity";
             status_enablefield(fld, fieldname, fieldfmt, TRUE);
             break;
         case BL_CO:
             fieldfmt = " Co:%s";
             fieldname = "constitution";
             status_enablefield(fld, fieldname, fieldfmt, TRUE);
             break;
         case BL_IN:
             fieldfmt = " In:%s";
             fieldname = "intelligence";
             status_enablefield(fld, fieldname, fieldfmt, TRUE);
             break;
         case BL_WI:
             fieldfmt = " Wi:%s";
             fieldname = "wisdom";
             status_enablefield(fld, fieldname, fieldfmt, TRUE);
             break;
         case BL_CH:
             fieldfmt = " Ch:%s";
             fieldname = "charisma";
             status_enablefield(fld, fieldname, fieldfmt, TRUE);
             break;
         case BL_ALIGN:
             fieldfmt = " %s";
             fieldname = "alignment";
             status_enablefield(fld, fieldname, fieldfmt, TRUE);
             break;
         case BL_SCORE:
             fieldfmt = " S:%s";
             fieldname = "score";
             status_enablefield(fld, fieldname, fieldfmt,
                                (!flags.showscore) ? FALSE : TRUE);
             break;
         case BL_CAP:
             fieldfmt = " %s";
             fieldname = "carrying-capacity";
             status_enablefield(fld, fieldname, fieldfmt, TRUE);
             break;
         case BL_GOLD:
             fieldfmt = " %s";
             fieldname = "gold";
             status_enablefield(fld, fieldname, fieldfmt, TRUE);
             break;
         case BL_ENE:
             fieldfmt = " Pw:%s";
             fieldname = "power";
             status_enablefield(fld, fieldname, fieldfmt, TRUE);
             break;
         case BL_ENEMAX:
             fieldfmt = "(%s)";
             fieldname = "power-max";
             status_enablefield(fld, fieldname, fieldfmt, TRUE);
             break;
         case BL_XP:
             fieldfmt = " Xp:%s";
             fieldname = "experience-level";
             status_enablefield(fld, fieldname, fieldfmt,
                                    (Upolyd) ? FALSE : TRUE);
             break;
         case BL_AC:
             fieldfmt = " AC:%s";
             fieldname = "armor-class";
             status_enablefield(fld, fieldname, fieldfmt, TRUE);
             break;
         case BL_HD:
             fieldfmt = " HD:%s";
             fieldname = "HD";
             status_enablefield(fld, fieldname, fieldfmt,
                                    (!Upolyd) ? FALSE : TRUE);
             break;
         case BL_TIME:
             fieldfmt = " T:%s";
             fieldname = "time";
             status_enablefield(fld, fieldname, fieldfmt,
                                    (!flags.time) ? FALSE : TRUE);
             break;
         case BL_HUNGER:
             fieldfmt = " %s";
             fieldname = "hunger";
             status_enablefield(fld, fieldname, fieldfmt, TRUE);
             break;
         case BL_HP:
             fieldfmt = " HP:%s";
             fieldname = "hitpoints";
             status_enablefield(fld, fieldname, fieldfmt, TRUE);
             break;
         case BL_HPMAX:
             fieldfmt = "(%s)";
             fieldname = "hitpoint-max";
             status_enablefield(fld, fieldname, fieldfmt, TRUE);
             break;
         case BL_LEVELDESC:
             fieldfmt = "%s";
             fieldname = "dungeon-level";
             status_enablefield(fld, fieldname, fieldfmt, TRUE);
             break;
         case BL_EXP:
             fieldfmt = "/%s";
             fieldname = "experience";
             status_enablefield(fld, fieldname, fieldfmt,
                                   (!flags.showexp || Upolyd) ? FALSE : TRUE);
             break;
         case BL_CONDITION:
             fieldfmt = "%S";
             fieldname = "condition";
             status_enablefield(fld, fieldname, fieldfmt, TRUE);
             break;
         case BL_FLUSH:
         default:
             break;
         }
     }
     update_all = TRUE;
 }
 

status_finish

 void
 status_finish()
 {
     int i;
 
     /* call the window port cleanup routine first */
     (*windowprocs.win_status_finish)();
 
     /* free memory that we alloc'd now */
     for (i = 0; i < MAXBLSTATS; ++i) {
         if (blstats[0][i].val)
             free((genericptr_t) blstats[0][i].val);
         if (blstats[1][i].val)
             free((genericptr_t) blstats[1][i].val);
     }
 }
 

init_blstats

 STATIC_OVL void
 init_blstats()
 {
     static boolean initalready = FALSE;
     int i, j;
 
     if (initalready) {
         impossible("init_blstats called more than once.");
         return;
     }
 
     initalready = TRUE;
     for (i = BEFORE; i <= NOW; ++i) {
         for (j = 0; j < MAXBLSTATS; ++j) {
             blstats[i][j] = initblstats[j];
             blstats[i][j].a = zeroany;
             if (blstats[i][j].valwidth) {
                 blstats[i][j].val = (char *) alloc(blstats[i][j].valwidth);
                 blstats[i][j].val[0] = '\0';
             } else
                 blstats[i][j].val = (char *) 0;
         }
     }
 }
 

anything_to_s

 STATIC_OVL char *
 anything_to_s(buf, a, anytype)
 char *buf;
 anything *a;
 int anytype;
 {
     if (!buf)
         return (char *) 0;
 
     switch (anytype) {
     case ANY_ULONG:
         Sprintf(buf, "%lu", a->a_ulong);
         break;
     case ANY_MASK32:
         Sprintf(buf, "%lx", a->a_ulong);
         break;
     case ANY_LONG:
         Sprintf(buf, "%ld", a->a_long);
         break;
     case ANY_INT:
         Sprintf(buf, "%d", a->a_int);
         break;
     case ANY_UINT:
         Sprintf(buf, "%u", a->a_uint);
         break;
     case ANY_IPTR:
         Sprintf(buf, "%d", *a->a_iptr);
         break;
     case ANY_LPTR:
         Sprintf(buf, "%ld", *a->a_lptr);
         break;
     case ANY_ULPTR:
         Sprintf(buf, "%lu", *a->a_ulptr);
         break;
     case ANY_UPTR:
         Sprintf(buf, "%u", *a->a_uptr);
         break;
     case ANY_STR: /* do nothing */
         ;
         break;
     default:
         buf[0] = '\0';
     }
     return buf;
 }
 

s_to_anything

 STATIC_OVL void
 s_to_anything(a, buf, anytype)
 anything *a;
 char *buf;
 int anytype;
 {
     if (!buf || !a)
         return;
 
     switch (anytype) {
     case ANY_LONG:
         a->a_long = atol(buf);
         break;
     case ANY_INT:
         a->a_int = atoi(buf);
         break;
     case ANY_UINT:
         a->a_uint = (unsigned) atoi(buf);
         break;
     case ANY_ULONG:
         a->a_ulong = (unsigned long) atol(buf);
         break;
     case ANY_IPTR:
         if (a->a_iptr)
             *a->a_iptr = atoi(buf);
         break;
     case ANY_UPTR:
         if (a->a_uptr)
             *a->a_uptr = (unsigned) atoi(buf);
         break;
     case ANY_LPTR:
         if (a->a_lptr)
             *a->a_lptr = atol(buf);
         break;
     case ANY_ULPTR:
         if (a->a_ulptr)
             *a->a_ulptr = (unsigned long) atol(buf);
         break;
     case ANY_MASK32:
         a->a_ulong = (unsigned long) atol(buf);
         break;
     default:
         a->a_void = 0;
         break;
     }
     return;
 }
 

compare_blstats

 STATIC_OVL int
 compare_blstats(bl1, bl2)
 struct istat_s *bl1, *bl2;
 {
     int anytype, result = 0;
 
     if (!bl1 || !bl2) {
         panic("compare_blstat: bad istat pointer %s, %s",
               fmt_ptr((genericptr_t) bl1), fmt_ptr((genericptr_t) bl2));
     }
 
     anytype = bl1->anytype;
     if ((!bl1->a.a_void || !bl2->a.a_void)
         && (anytype == ANY_IPTR || anytype == ANY_UPTR || anytype == ANY_LPTR
             || anytype == ANY_ULPTR)) {
         panic("compare_blstat: invalid pointer %s, %s",
               fmt_ptr((genericptr_t) bl1->a.a_void),
               fmt_ptr((genericptr_t) bl2->a.a_void));
     }
 
     switch (anytype) {
     case ANY_INT:
         result = (bl1->a.a_int < bl2->a.a_int)
                      ? 1
                      : (bl1->a.a_int > bl2->a.a_int) ? -1 : 0;
         break;
     case ANY_IPTR:
         result = (*bl1->a.a_iptr < *bl2->a.a_iptr)
                      ? 1
                      : (*bl1->a.a_iptr > *bl2->a.a_iptr) ? -1 : 0;
         break;
     case ANY_LONG:
         result = (bl1->a.a_long < bl2->a.a_long)
                      ? 1
                      : (bl1->a.a_long > bl2->a.a_long) ? -1 : 0;
         break;
     case ANY_LPTR:
         result = (*bl1->a.a_lptr < *bl2->a.a_lptr)
                      ? 1
                      : (*bl1->a.a_lptr > *bl2->a.a_lptr) ? -1 : 0;
         break;
     case ANY_UINT:
         result = (bl1->a.a_uint < bl2->a.a_uint)
                      ? 1
                      : (bl1->a.a_uint > bl2->a.a_uint) ? -1 : 0;
         break;
     case ANY_UPTR:
         result = (*bl1->a.a_uptr < *bl2->a.a_uptr)
                      ? 1
                      : (*bl1->a.a_uptr > *bl2->a.a_uptr) ? -1 : 0;
         break;
     case ANY_ULONG:
         result = (bl1->a.a_ulong < bl2->a.a_ulong)
                      ? 1
                      : (bl1->a.a_ulong > bl2->a.a_ulong) ? -1 : 0;
         break;
     case ANY_ULPTR:
         result = (*bl1->a.a_ulptr < *bl2->a.a_ulptr)
                      ? 1
                      : (*bl1->a.a_ulptr > *bl2->a.a_ulptr) ? -1 : 0;
         break;
     case ANY_STR:
         if (strcmp(bl1->val, bl2->val) == 0)
             result = 0;
         else
             result = 1;
         break;
     case ANY_MASK32:
         if (bl1->a.a_ulong == bl2->a.a_ulong)
             result = 0;
         else
             result = 1;
         break;
     default:
         result = 1;
     }
     return result;
 }
 

percentage

 STATIC_OVL int
 percentage(bl, maxbl)
 struct istat_s *bl, *maxbl;
 {
     int result = 0;
     int anytype;
 
     if (!bl || !maxbl) {
         impossible("percentage: bad istat pointer %s, %s",
                    fmt_ptr((genericptr_t) bl), fmt_ptr((genericptr_t) maxbl));
         return 0;
     }
 
     anytype = bl->anytype;
     if (maxbl->a.a_void) {
         switch (anytype) {
         case ANY_INT:
             result = ((100 * bl->a.a_int) / maxbl->a.a_int);
             break;
         case ANY_LONG:
             result = (int) ((100L * bl->a.a_long) / maxbl->a.a_long);
             break;
         case ANY_UINT:
             result = (int) ((100U * bl->a.a_uint) / maxbl->a.a_uint);
             break;
         case ANY_ULONG:
             result = (int) ((100UL * bl->a.a_ulong) / maxbl->a.a_ulong);
             break;
         case ANY_IPTR:
             result = ((100 * (*bl->a.a_iptr)) / (*maxbl->a.a_iptr));
             break;
         case ANY_LPTR:
             result = (int) ((100L * (*bl->a.a_lptr)) / (*maxbl->a.a_lptr));
             break;
         case ANY_UPTR:
             result = (int) ((100U * (*bl->a.a_uptr)) / (*maxbl->a.a_uptr));
             break;
         case ANY_ULPTR:
             result = (int) ((100UL * (*bl->a.a_ulptr)) / (*maxbl->a.a_ulptr));
             break;
         }
     }
     return result;
 }
 
 

set_status_hilites

 #ifdef STATUS_HILITES
 
 /****************************************************************************/
 /* Core status hiliting support */
 /****************************************************************************/
 
 struct hilite_s {
     boolean set;
     unsigned anytype;
     anything threshold;
     int behavior;
     int coloridx[2];
 };
 
 struct hilite_s status_hilites[MAXBLSTATS];
 
 /*
  * This is the parser for the hilite options
  * Example:
  *    OPTION=hilite_status: hitpoints/10%/red/normal
  *
  * set_hilite_status() separates each hilite entry into its 4 component
  * strings, then calls assign_hilite() to make the adjustments.
  */
 boolean
 set_status_hilites(op, from_configfile)
 char *op;
 boolean from_configfile;
 {
     char hsbuf[4][QBUFSZ];
     boolean rslt, badopt = FALSE;
     int fldnum, num = 0, ccount = 0;
     char c;
 
     num = fldnum = 0;
     hsbuf[0][0] = hsbuf[1][0] = hsbuf[2][0] = hsbuf[3][0] = '\0';
     while (*op && fldnum < 4 && ccount < (QBUFSZ - 2)) {
         c = lowc(*op);
         if (c == ' ') {
             if (fldnum >= 2) {
                 rslt = assign_hilite(&hsbuf[0][0], &hsbuf[1][0], &hsbuf[2][0],
                                      &hsbuf[3][0], from_configfile);
                 if (!rslt) {
                     badopt = TRUE;
                     break;
                 }
             }
             hsbuf[0][0] = hsbuf[1][0] = '\0';
             hsbuf[2][0] = hsbuf[3][0] = '\0';
             fldnum = 0;
             ccount = 0;
         } else if (c == '/') {
             fldnum++;
             ccount = 0;
         } else {
             hsbuf[fldnum][ccount++] = c;
             hsbuf[fldnum][ccount] = '\0';
         }
         op++;
     }
     if (fldnum >= 2 && !badopt) {
         rslt = assign_hilite(&hsbuf[0][0], &hsbuf[1][0], &hsbuf[2][0],
                              &hsbuf[3][0], from_configfile);
         if (!rslt)
             badopt = TRUE;
     }
     if (badopt)
         return FALSE;
     return TRUE;
 }
 

clear_status_hilites

 void
 clear_status_hilites(from_configfile)
 boolean from_configfile;
 {
     int i;
     anything it;
     it = zeroany;
     for (i = 0; i < MAXBLSTATS; ++i) {
         (void) memset((genericptr_t) &status_hilites[i], 0,
                       sizeof(struct hilite_s));
         /* notify window port */
         if (!from_configfile)
             status_threshold(i, blstats[0][i].anytype, it, 0, 0, 0);
     }
 }
 

assign_hilite

 STATIC_OVL boolean
 assign_hilite(sa, sb, sc, sd, from_configfile)
 char *sa, *sb, *sc, *sd;
 boolean from_configfile;
 {
     char *tmp, *how;
     int i = -1, dt = -1, idx = -1;
     int coloridx[2] = { -1, -1 };
     boolean inverse[2] = { FALSE, FALSE };
     boolean bold[2] = { FALSE, FALSE };
     boolean normal[2] = { 0, 0 };
     boolean percent = FALSE, down_up = FALSE, changed = FALSE;
     anything threshold;
     enum statusfields fld = BL_FLUSH;
     threshold.a_void = 0;
 
     /* Example:
      *  hilite_status: hitpoints/10%/red/normal
      */
 
     /* field name to statusfield */
     for (i = 0; sa && i < SIZE(fieldids); ++i) {
         if (strcmpi(sa, fieldids[i].fieldname) == 0) {
             idx = i;
             fld = fieldids[i].fldid;
             break;
         }
     }
     if (idx == -1)
         return FALSE;
     status_hilites[idx].set = FALSE; /* mark it "unset" */
 
     /* threshold */
     if (!sb)
         return FALSE;
     if ((strcmpi(sb, "updown") == 0) || (strcmpi(sb, "downup") == 0)
         || (strcmpi(sb, "up") == 0) || (strcmpi(sb, "down") == 0)) {
         down_up = TRUE;
     } else if ((strcmpi(sb, "changed") == 0)
                && (fld == BL_TITLE || fld == BL_ALIGN || fld == BL_LEVELDESC
                    || fld == BL_CONDITION)) {
         changed = TRUE; /* changed is only thing allowed */
     } else {
         tmp = sb;
         while (*tmp) {
             if (*tmp == '%') {
                 *tmp = '\0';
                 percent = TRUE;
                 break;
             } else if (!index("0123456789", *tmp))
                 return FALSE;
             tmp++;
         }
         if (strlen(sb) > 0) {
             dt = blstats[0][idx].anytype;
             if (percent)
                 dt = ANY_INT;
             (void) s_to_anything(&threshold, sb, dt);
         } else
             return FALSE;
         if (percent && (threshold.a_int < 1 || threshold.a_int > 100))
             return FALSE;
         if (!threshold.a_void && (strcmp(sb, "0") != 0))
             return FALSE;
     }
 
     /* actions */
     for (i = 0; i < 2; ++i) {
         if (!i)
             how = sc;
         else
             how = sd;
         if (!how) {
             if (!i)
                 return FALSE;
             else
                 break; /* sc is mandatory; sd is not */
         }
 
         if (strcmpi(how, "bold") == 0) {
             bold[i] = TRUE;
         } else if (strcmpi(how, "inverse") == 0) {
             inverse[i] = TRUE;
         } else if (strcmpi(how, "normal") == 0) {
             normal[i] = TRUE;
         } else {
             int k;
             char colorname[BUFSZ];
             for (k = 0; k < CLR_MAX; ++k) {
                 /* we have to make a copy to change space to dash */
                 (void) strcpy(colorname, c_obj_colors[k]);
                 for (tmp = index(colorname, ' '); tmp;
                      tmp = index(colorname, ' '))
                     *tmp = '-';
                 if (strcmpi(how, colorname) == 0) {
                     coloridx[i] = k;
                     break;
                 }
             }
             if (k >= CLR_MAX)
                 return FALSE;
         }
     }
 
     /* Assign the values */
 
     for (i = 0; i < 2; ++i) {
         if (inverse[i])
             status_hilites[idx].coloridx[i] = BL_HILITE_INVERSE;
         else if (bold[i])
             status_hilites[idx].coloridx[i] = BL_HILITE_BOLD;
         else if (coloridx[i])
             status_hilites[idx].coloridx[i] = coloridx[i];
         else
             status_hilites[idx].coloridx[i] = BL_HILITE_NONE;
     }
 
     if (percent)
         status_hilites[idx].behavior = BL_TH_VAL_PERCENTAGE;
     else if (down_up)
         status_hilites[idx].behavior = BL_TH_UPDOWN;
     else if (threshold.a_void)
         status_hilites[idx].behavior = BL_TH_VAL_ABSOLUTE;
     else
         status_hilites[idx].behavior = BL_TH_NONE;
 
     if (status_hilites[idx].behavior != BL_TH_NONE) {
         status_hilites[idx].threshold = threshold;
         status_hilites[idx].set = TRUE;
     }
     status_hilites[idx].anytype = dt;
 
     /* Now finally, we notify the window port */
     if (!from_configfile)
         status_threshold(idx, status_hilites[idx].anytype,
                         status_hilites[idx].threshold,
                         status_hilites[idx].behavior,
                         status_hilites[idx].coloridx[0],
                         status_hilites[idx].coloridx[1]);
 
     return TRUE;
 }
 

status_notify_windowport

 void
 status_notify_windowport(all)
 boolean all;
 {
     int idx;
     anything it;
 
     it = zeroany;
     for (idx = 0; idx < MAXBLSTATS; ++idx) {
         if (status_hilites[idx].set)
             status_threshold(idx, status_hilites[idx].anytype,
                             status_hilites[idx].threshold,
                             status_hilites[idx].behavior,
                             status_hilites[idx].coloridx[0],
                             status_hilites[idx].coloridx[1]);
         else
             status_threshold(idx, blstats[0][idx].anytype, it, 0, 0, 0);
 
     }
 }
 

get_status_hilites

 /*
  * get_status_hilites
  *
  * Returns a string containing all the status hilites in the
  * same format that is used to specify a status hilite preference
  * in the config file.
  */
 char *
 get_status_hilites(buf, bufsiz)
 char *buf;
 int bufsiz;
 {
     int i, j, k, coloridx;
     const char *text = (char *) 0;
     char tmp[BUFSZ], colorname[BUFSZ];
     boolean val_percentage, val_absolute, up_down;
     boolean added_one = FALSE;
 
     if (!buf)
         return (char *) 0;
     *buf = '\0';
 
     bufsiz--; /* required trailing null */
     for (i = 0; i < MAXBLSTATS; ++i) {
         val_percentage = val_absolute = up_down = FALSE;
         if (status_hilites[i].set) {
             if (!added_one)
                 added_one = TRUE;
             else {
                 Strcat(buf, " ");
                 bufsiz--;
             }
             k = strlen(fieldids[i].fieldname);
             if (k < bufsiz) {
                 Strcat(buf, fieldids[i].fieldname);
                 bufsiz -= k;
             }
             if (bufsiz > 1) {
                 Strcat(buf, "/");
                 bufsiz--;
             }
             if (status_hilites[i].behavior == BL_TH_VAL_PERCENTAGE) {
                 val_percentage = TRUE;
             } else if (status_hilites[i].behavior == BL_TH_VAL_ABSOLUTE) {
                 val_absolute = TRUE;
             } else if (status_hilites[i].behavior == BL_TH_UPDOWN) {
                 up_down = TRUE;
                 text = "updown";
             }
 
             if (status_hilites[i].behavior != BL_TH_UPDOWN) {
                 anything_to_s(tmp, &status_hilites[i].threshold,
                           blstats[0][i].anytype);
                 text = tmp;
             }
             k = strlen(text);
             if (k < (bufsiz - 1)) {
                 Strcat(buf, text);
                 if (val_percentage)
                     Strcat(buf, "%"), k++;
                 bufsiz -= k;
             }
             for (j = 0; j < 2; ++j) {
                 if (bufsiz > 1) {
                     Strcat(buf, "/");
                     bufsiz--;
                 }
                 coloridx = status_hilites[i].coloridx[j];
                 if (coloridx < 0) {
                     if (coloridx == BL_HILITE_BOLD)
                         text = "bold";
                     else if (coloridx == BL_HILITE_INVERSE)
                         text = "inverse";
                     else
                         text = "normal";
                 } else {
                     char *blank;
                     (void) strcpy(colorname, c_obj_colors[coloridx]);
                     for (blank = index(colorname, ' '); blank;
                          blank = index(colorname, ' '))
                         *blank = '-';
                     text = colorname;
                 }
                 k = strlen(text);
                 if (k < bufsiz) {
                     Strcat(buf, text);
                     bufsiz -= k;
                 }
             }
         }
     }
     return buf;
 }
 

clridx_to_s

 STATIC_OVL const char *
 clridx_to_s(buf, idx)
 char *buf;
 int idx;
 {
     static const char *a[] = { "bold", "inverse", "normal" };
     char* p = 0;
 
     if (buf) {
         buf[0] = '\0';
         if (idx < 0 && idx >= BL_HILITE_BOLD)
             Strcpy(buf, a[idx + 3]);
         else if (idx >= 0 && idx < CLR_MAX)
             Strcpy(buf, c_obj_colors[idx]);
         /* replace spaces with - */
         for(p = buf; *p; p++)
             if(*p == ' ') *p = '-';
     }
     return buf;
 }
 

status_hilite_menu

 boolean
 status_hilite_menu()
 {
     int i, j, k, pick_cnt, pick_idx, opt_idx;
     menu_item *statfield_picks = (menu_item *) 0;
     const char *fieldname;
     int field_picks[MAXBLSTATS], res;
     struct hilite_s hltemp[MAXBLSTATS];
     char buf[BUFSZ], thresholdbuf[BUFSZ], below[BUFSZ], above[BUFSZ];
     winid tmpwin;
     anything any;
 
     tmpwin = create_nhwindow(NHW_MENU);
     start_menu(tmpwin);
     for (i = 0; i < MAXBLSTATS; i++) {
         (void) memset(&hltemp[i], 0, sizeof(struct hilite_s));
         fieldname = fieldids[i].fieldname;
         any.a_int = i + 1;
         add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE, fieldname,
                  MENU_UNSELECTED);
         field_picks[i] = 0;
     }
     end_menu(tmpwin, "Change hilite on which status field(s):");
     if ((pick_cnt = select_menu(tmpwin, PICK_ANY, &statfield_picks)) > 0) {
         for (pick_idx = 0; pick_idx < pick_cnt; ++pick_idx) {
             opt_idx = statfield_picks[pick_idx].item.a_int - 1;
             field_picks[opt_idx] = 1;
         }
         free((genericptr_t) statfield_picks);
         statfield_picks = (menu_item *) 0;
     }
     destroy_nhwindow(tmpwin);
     if (pick_cnt < 0)
         return FALSE;
 
     for (i = 0; i < MAXBLSTATS; i++) {
         if (field_picks[i]) {
             menu_item *pick = (menu_item *) 0;
             Sprintf(buf, "Threshold behavior options for %s:",
                     fieldids[i].fieldname);
             tmpwin = create_nhwindow(NHW_MENU);
             start_menu(tmpwin);
             if (i == BL_CONDITION) {
                 any = zeroany;
                 any.a_int = BL_TH_CONDITION + 1;
                 add_menu(tmpwin, NO_GLYPH, &any, 'c', 0, ATR_NONE,
                          "Condition bitmask threshold.", MENU_UNSELECTED);
             }
             any = zeroany;
             any.a_int = BL_TH_NONE + 1;
             add_menu(tmpwin, NO_GLYPH, &any, 'n', 0, ATR_NONE, "None",
                      MENU_UNSELECTED);
             if (i != BL_CONDITION) {
                 if (blstats[0][i].idxmax > 0) {
                     any = zeroany;
                     any.a_int = BL_TH_VAL_PERCENTAGE + 1;
                     add_menu(tmpwin, NO_GLYPH, &any, 'p', 0, ATR_NONE,
                              "Percentage threshold.", MENU_UNSELECTED);
                 }
                 any = zeroany;
                 any.a_int = BL_TH_UPDOWN + 1;
                 add_menu(tmpwin, NO_GLYPH, &any, 'u', 0, ATR_NONE,
                          "UpDown threshold.", MENU_UNSELECTED);
                 any = zeroany;
                 any.a_int = BL_TH_VAL_ABSOLUTE + 1;
                 add_menu(tmpwin, NO_GLYPH, &any, 'v', 0, ATR_NONE,
                          "Value threshold.", MENU_UNSELECTED);
             }
             end_menu(tmpwin, buf);
             if ((res = select_menu(tmpwin, PICK_ONE, &pick)) > 0) {
                 hltemp[i].behavior = pick->item.a_int - 1;
                 free((genericptr_t) pick);
             }
             destroy_nhwindow(tmpwin);
             if (res < 0)
                 return FALSE;
 
             if (hltemp[i].behavior == BL_TH_UPDOWN) {
                 Sprintf(below, "%s decreases", fieldids[i].fieldname);
                 Sprintf(above, "%s increases", fieldids[i].fieldname);
             } else if (hltemp[i].behavior) {
                 /* Have them enter the threshold*/
                 Sprintf(
                     buf, "Set %s threshold to what%s?", fieldids[i].fieldname,
                     (hltemp[i].behavior == BL_TH_VAL_PERCENTAGE)
                         ? " percentage"
                         : (hltemp[i].behavior == BL_TH_CONDITION) ? " mask"
                                                                   : "");
                 getlin(buf, thresholdbuf);
                 if (thresholdbuf[0] == '\033')
                     return FALSE;
                 (void) s_to_anything(&hltemp[i].threshold, thresholdbuf,
                                      blstats[0][i].anytype);
                 if (!hltemp[i].threshold.a_void)
                     return FALSE;
 
                 Sprintf(below, "%s falls below %s%s", fieldids[i].fieldname,
                         thresholdbuf,
                         (hltemp[i].behavior == BL_TH_VAL_PERCENTAGE) ? "%"
                                                                      : "");
                 Sprintf(above, "%s rises above %s%s", fieldids[i].fieldname,
                         thresholdbuf,
                         (hltemp[i].behavior == BL_TH_VAL_PERCENTAGE) ? "%"
                                                                      : "");
             }
             for (j = 0; j < 2 && (hltemp[i].behavior != BL_TH_NONE); ++j) {
                 char prompt[QBUFSZ];
                 /* j == 0 below, j == 1 above */
                 menu_item *pick2 = (menu_item *) 0;
 
                 Sprintf(prompt, "Display how when %s?", j ? above : below);
                 tmpwin = create_nhwindow(NHW_MENU);
                 start_menu(tmpwin);
                 for (k = -3; k < CLR_MAX; ++k) {
                     /* if (k == -1) continue; */
                     any = zeroany;
                     any.a_int = (k >= 0) ? k + 1 : k;
                     if (k > 0)
                         add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE,
                                  c_obj_colors[k], MENU_UNSELECTED);
                     else if (k == -1)
                         add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE,
                                  "normal", MENU_UNSELECTED);
                     else if (k == -2)
                         add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE,
                                  "inverse", MENU_UNSELECTED);
                     else if (k == -3)
                         add_menu(tmpwin, NO_GLYPH, &any, 0, 0, ATR_NONE,
                                  "bold", MENU_UNSELECTED);
                 }
                 end_menu(tmpwin, prompt);
                 if ((res = select_menu(tmpwin, PICK_ONE, &pick2)) > 0) {
                     hltemp[i].coloridx[j] = (pick2->item.a_char > 0)
                                                 ? pick2->item.a_int - 1
                                                 : pick2->item.a_int;
                     free((genericptr_t) pick2);
                 }
                 destroy_nhwindow(tmpwin);
                 if (res < 0)
                     return FALSE;
             }
         }
     }
     buf[0] = '\0';
     for (i = 0; i < MAXBLSTATS; i++) {
         if (field_picks[i]) {
             Sprintf(eos(buf), "%s/%s%s/", fieldids[i].fieldname,
                     (hltemp[i].behavior == BL_TH_UPDOWN)
                         ? "updown"
                         : anything_to_s(thresholdbuf, &hltemp[i].threshold,
                                         blstats[0][i].anytype),
                     (hltemp[i].behavior == BL_TH_VAL_PERCENTAGE) ? "%" : "");
             /* borrow thresholdbuf for use with these last two */
             Sprintf(eos(buf), "%s/",
                     clridx_to_s(thresholdbuf, hltemp[i].coloridx[0]));
             Sprintf(eos(buf), "%s ",
                     clridx_to_s(thresholdbuf, hltemp[i].coloridx[1]));
         }
     }
     return set_status_hilites(buf, FALSE);
 }
 #endif /*STATUS_HILITES*/
 #endif /*STATUS_VIA_WINDOWPORT*/
 
 /*botl.c*/