Fandom

Wikihack

Source:SLASH'EM 0.0.7E7F2/botl.c

2,034pages on
this wiki
Add New Page
Talk0

Ad blocker interference detected!


Wikia is a free-to-use site that makes money from advertising. We have a modified experience for viewers using ad blockers

Wikia is not accessible if you’ve made further modifications. Remove the custom ad blocker rule(s) and the page will load as expected.

Below is the full text to botl.c from the source code of SLASH'EM 0.0.7E7F2. To link to a particular line, write [[SLASH'EM 0.0.7E7F2/botl.c#line123]], for example.

The latest source code for vanilla NetHack is at Source code.


The NetHack General Public License applies to screenshots, source code and other content from NetHack.
1.    /*	SCCS Id: @(#)botl.c	3.4	1996/07/15	*/
2.    /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
3.    /* NetHack may be freely redistributed.  See license for details. */
4.    
5.    #include "hack.h"
6.    
7.    #ifdef OVL0
8.    extern const char *hu_stat[];	/* defined in eat.c */
9.    
10.   const char *hu_abbrev_stat[] = {	/* must be kept consistent with eat.c */
11.   	"Sat",
12.   	"",
13.   	"Hun",
14.   	"Wea",
15.   	"Ftg",
16.   	"Ftd",
17.   	"Sta"
18.   };
19.   
20.   const char * const enc_stat[] = {
21.   	"",
22.   	"Burdened",
23.   	"Stressed",
24.   	"Strained",
25.   	"Overtaxed",
26.   	"Overloaded"
27.   };
28.   
29.   const char *enc_abbrev_stat[] = {
30.   	"",
31.   	"Brd",
32.   	"Ssd",
33.   	"Snd",
34.   	"Otd",
35.   	"Old"
36.   };
37.   
38.   STATIC_DCL void NDECL(bot1);
39.   STATIC_DCL void NDECL(bot2);
40.   #ifdef ALLEG_FX
41.   STATIC_DCL void FDECL(set_botl_warn, (int));
42.   #endif
43.   #endif /* OVL0 */
44.   
45.   /* MAXCO must hold longest uncompressed status line, and must be larger
46.    * than COLNO
47.    *
48.    * longest practical second status line at the moment is
49.    *	Astral Plane $:12345 HP:700(700) Pw:111(111) AC:-127 Xp:30/123456789
50.    *      Wt:5000/1000 T:123456 Satiated Lev Conf FoodPois Ill Blind Stun Hallu
51.    *      Slime Held Overloaded
52.    * -- or somewhat over 160 characters
53.    */
54.   #if COLNO <= 170
55.   #define MAXCO 190
56.   #else
57.   #define MAXCO (COLNO+20)
58.   #endif
59.   
60.   #ifndef OVLB
61.   STATIC_DCL int mrank_sz;
62.   #else /* OVLB */
63.   STATIC_OVL NEARDATA int mrank_sz = 0; /* loaded by max_rank_sz (from u_init) */
64.   #endif /* OVLB */
65.   
66.   STATIC_DCL const char *NDECL(rank);
67.   
68.   #ifdef OVL1
69.   
70.   #ifdef ALLEG_FX
71.   static int botl_warn = 0;
72.   
73.   static void
74.   set_botl_warn(level)
75.   int level;
76.   {
77.           botl_warn = level;
78.           flags.botl = 1;
79.   }
80.   #endif
81.   
82.   /* convert experience level (1..30) to rank index (0..8) */
83.   int
84.   xlev_to_rank(xlev)
85.   int xlev;
86.   {
87.   	return (xlev <= 2) ? 0 : (xlev <= 30) ? ((xlev + 2) / 4) : 8;
88.   }
89.   
90.   #if 0	/* not currently needed */
91.   /* convert rank index (0..8) to experience level (1..30) */
92.   int
93.   rank_to_xlev(rank)
94.   int rank;
95.   {
96.   	return (rank <= 0) ? 1 : (rank <= 8) ? ((rank * 4) - 2) : 30;
97.   }
98.   #endif
99.   
100.  const char *
101.  rank_of(lev, monnum, female)
102.  int lev;
103.  	short monnum;
104.  boolean female;
105.  {
106.  	register struct Role *role;
107.  	register int i;
108.  
109.  
110.  	/* Find the role */
111.  	for (role = (struct Role *) roles; role->name.m; role++)
112.  	    if (monnum == role->malenum || monnum == role->femalenum)
113.  	    	break;
114.  	if (!role->name.m)
115.  	    role = &urole;
116.  
117.  	/* Find the rank */
118.  	for (i = xlev_to_rank((int)lev); i >= 0; i--) {
119.  	    if (female && role->rank[i].f) return (role->rank[i].f);
120.  	    if (role->rank[i].m) return (role->rank[i].m);
121.  	}
122.  
123.  	/* Try the role name, instead */
124.  	if (female && role->name.f) return (role->name.f);
125.  	else if (role->name.m) return (role->name.m);
126.  	return ("Player");
127.  }
128.  
129.  
130.  STATIC_OVL const char *
131.  rank()
132.  {
133.  	return(rank_of(u.ulevel, Role_switch, flags.female));
134.  }
135.  
136.  int
137.  title_to_mon(str, rank_indx, title_length)
138.  const char *str;
139.  int *rank_indx, *title_length;
140.  {
141.  	register int i, j;
142.  
143.  
144.  	/* Loop through each of the roles */
145.  	for (i = 0; roles[i].name.m; i++)
146.  	    for (j = 0; j < 9; j++) {
147.  	    	if (roles[i].rank[j].m && !strncmpi(str,
148.  	    			roles[i].rank[j].m, strlen(roles[i].rank[j].m))) {
149.  	    	    if (rank_indx) *rank_indx = j;
150.  	    	    if (title_length) *title_length = strlen(roles[i].rank[j].m);
151.  	    	    return roles[i].malenum;
152.  	    	}
153.  	    	if (roles[i].rank[j].f && !strncmpi(str,
154.  	    			roles[i].rank[j].f, strlen(roles[i].rank[j].f))) {
155.  	    	    if (rank_indx) *rank_indx = j;
156.  	    	    if (title_length) *title_length = strlen(roles[i].rank[j].f);
157.  	    	    return ((roles[i].femalenum != NON_PM) ?
158.  	    	    		roles[i].femalenum : roles[i].malenum);
159.  	    	}
160.  	    }
161.  	return NON_PM;
162.  }
163.  
164.  #endif /* OVL1 */
165.  #ifdef OVLB
166.  
167.  void
168.  max_rank_sz()
169.  {
170.  	register int i, r, maxr = 0;
171.  
172.  
173.  	for (i = 0; i < 9; i++) {
174.  	    if (urole.rank[i].m && (r = strlen(urole.rank[i].m)) > maxr) maxr = r;
175.  	    if (urole.rank[i].f && (r = strlen(urole.rank[i].f)) > maxr) maxr = r;
176.  	}
177.  	mrank_sz = maxr;
178.  	return;
179.  }
180.  
181.  #endif /* OVLB */
182.  #ifdef OVL0
183.  
184.  #ifdef SCORE_ON_BOTL
185.  long
186.  botl_score()
187.  {
188.      int deepest = deepest_lev_reached(FALSE);
189.  #ifndef GOLDOBJ
190.      long ugold = u.ugold + hidden_gold();
191.  
192.      if ((ugold -= u.ugold0) < 0L) ugold = 0L;
193.      return ugold + u.urexp + (long)(50 * (deepest - 1))
194.  #else
195.      long umoney = money_cnt(invent) + hidden_gold();
196.  
197.      if ((umoney -= u.umoney0) < 0L) umoney = 0L;
198.      return umoney + u.urexp + (long)(50 * (deepest - 1))
199.  #endif
200.  			  + (long)(deepest > 30 ? 10000 :
201.  				   deepest > 20 ? 1000*(deepest - 20) : 0);
202.  }
203.  #endif
204.  
205.  static char *
206.  botl_player()
207.  {
208.      static char player[MAXCO];
209.  	register char *nb;
210.      char mbot[MAXCO - 15];
211.      int k = 0;
212.  
213.      Strcpy(player, plname);
214.      if ('a' <= player[0] && player[0] <= 'z') player[0] += 'A'-'a';
215.      player[10] = 0;
216.      Sprintf(nb = eos(player)," the ");
217.  
218.  	if (Upolyd) {
219.  	(void) strncpy(mbot, mons[u.umonnum].mname, SIZE(mbot) - 1);
220.  	mbot[SIZE(mbot) - 1] = 0;
221.  		while(mbot[k] != 0) {
222.  		    if ((k == 0 || (k > 0 && mbot[k-1] == ' ')) &&
223.  					'a' <= mbot[k] && mbot[k] <= 'z')
224.  			mbot[k] += 'A' - 'a';
225.  		    k++;
226.  		}
227.  	Sprintf(eos(nb), mbot);
228.  	} else
229.  	Sprintf(eos(nb), rank());
230.      return player;
231.  }
232.  
233.  static char *
234.  botl_strength()
235.  {
236.      static char strength[6];
237.  	if (ACURR(A_STR) > 18) {
238.  		if (ACURR(A_STR) > STR18(100))
239.  	    Sprintf(strength, "%2d", ACURR(A_STR)-100);
240.  		else if (ACURR(A_STR) < STR18(100))
241.  	    Sprintf(strength, "18/%02d", ACURR(A_STR)-18);
242.  		else
243.  	    Sprintf(strength, "18/**");
244.  	} else
245.  	Sprintf(strength, "%-1d", ACURR(A_STR));
246.      return strength;
247.  }
248.  
249.  STATIC_OVL void
250.  bot1()
251.  {
252.  	char newbot1[MAXCO];
253.  	register char *nb;
254.  	register int i,j;
255.  
256.  	Strcpy(newbot1, botl_player());
257.  	Sprintf(nb = eos(newbot1),"  ");
258.  	i = mrank_sz + 15;
259.  	j = (nb + 2) - newbot1; /* aka strlen(newbot1) but less computation */
260.  	if((i - j) > 0)
261.  		Sprintf(nb = eos(nb),"%*s", i-j, " ");  /* pad with spaces */
262.          
263.  	Sprintf(nb = eos(nb), "St:%s ", botl_strength());
264.  	Sprintf(nb = eos(nb),
265.  		"Dx:%-1d Co:%-1d In:%-1d Wi:%-1d Ch:%-1d",
266.  		ACURR(A_DEX), ACURR(A_CON), ACURR(A_INT), ACURR(A_WIS), ACURR(A_CHA));
267.  	Sprintf(nb = eos(nb), (u.ualign.type == A_CHAOTIC) ? "  Chaotic" :
268.  			(u.ualign.type == A_NEUTRAL) ? "  Neutral" : "  Lawful");
269.  #ifdef SCORE_ON_BOTL
270.  	if (flags.showscore)
271.  	    Sprintf(nb = eos(nb), " S:%ld", botl_score());
272.  #endif
273.  	curs(WIN_STATUS, 1, 0);
274.  	putstr(WIN_STATUS, 0, newbot1);
275.  }
276.  
277.  /* provide the name of the current level for display by various ports */
278.  int
279.  describe_level(buf, verbose)
280.  char *buf;
281.  int verbose;
282.  {
283.  	int ret = 1;
284.  
285.  	/* TODO:	Add in dungeon name */
286.  	if (Is_knox(&u.uz))
287.  		Sprintf(buf, "%s ", dungeons[u.uz.dnum].dname);
288.  	else if (In_quest(&u.uz))
289.  		Sprintf(buf, "Home %d ", dunlev(&u.uz));
290.  	else if (In_endgame(&u.uz))
291.  		Sprintf(buf,
292.  			Is_astralevel(&u.uz) ? "Astral Plane " : "End Game ");
293.  	else {
294.  		if (verbose)
295.  			Sprintf(buf, "%s, level %d ",
296.  				dungeons[u.uz.dnum].dname, depth(&u.uz));
297.  		else
298.  		Sprintf(buf, "Dlvl:%-2d ", depth(&u.uz));
299.  		ret = 0;
300.  	}
301.  	return ret;
302.  }
303.  
304.  /* [ALI] Line 2 abbreviation levels:
305.   *	0 - No abbreviation
306.   *	1 - Omit gold
307.   *	2 - Abbreviated status tags
308.   *	3 - Disable show options
309.   *	4 - Omit dungeon level
310.   *
311.   * We omit gold first since the '$' command is always available.
312.   *
313.   * While the abbreviated status tags are very difficult to interpret, we use
314.   * these before disabling the show options on the basis that the user always
315.   * has the choice of turning the show options off if that would be preferable.
316.   *
317.   * Last to go is the dungeon level on the basis that there is no way of
318.   * finding this information other than via the status line.
319.   */
320.  
321.  static int bot2_abbrev = 0;	/* Line 2 abbreviation level (max 4) */
322.  
323.  STATIC_OVL void
324.  bot2str(char *newbot2)
325.  {
326.  	register char *nb;
327.  	int hp, hpmax;
328.  	int cap = near_capacity();
329.  #ifdef ALLEG_FX
330.  	int w;
331.  #endif
332.  
333.  	hp = Upolyd ? u.mh : u.uhp;
334.  	hpmax = Upolyd ? u.mhmax : u.uhpmax;
335.  
336.  	if(hp < 0) hp = 0;
337.  	if (bot2_abbrev < 4)
338.  		(void) describe_level(newbot2, FALSE);
339.  	else
340.  		newbot2[0] = '\0';
341.  	if (bot2_abbrev < 1)
342.  		Sprintf(nb = eos(newbot2), "%c:%-2ld ",
343.  		  oc_syms[COIN_CLASS],
344.  #ifndef GOLDOBJ
345.  		u.ugold
346.  #else
347.  		money_cnt(invent)
348.  #endif
349.  		  );
350.  	else
351.  		nb = newbot2;
352.  	Sprintf(nb = eos(nb), "HP:%d(%d) Pw:%d(%d) AC:%-2d",
353.  		hp, hpmax, u.uen, u.uenmax, u.uac);
354.  
355.  	if (Upolyd)
356.  		Sprintf(nb = eos(nb), " HD:%d", ((u.ulycn == u.umonnum) ? 
357.  						u.ulevel : mons[u.umonnum].mlevel));
358.  #ifdef EXP_ON_BOTL
359.  	else if(flags.showexp && bot2_abbrev < 3)
360.  		Sprintf(nb = eos(nb), " Xp:%u/%-1ld", u.ulevel,u.uexp);
361.  #endif
362.  	else
363.  		Sprintf(nb = eos(nb), " Exp:%u", u.ulevel);
364.  
365.  #ifdef SHOW_WEIGHT
366.  	if (flags.showweight && bot2_abbrev < 3)
367.  		Sprintf(nb = eos(nb), "  Wt:%ld/%ld", (long)(inv_weight()+weight_cap()),
368.  				(long)weight_cap());
369.  #endif
370.  
371.  	if(flags.time && bot2_abbrev < 3)
372.  	        Sprintf(nb = eos(nb), "  T:%ld ", moves);
373.  
374.  #ifdef ALLEG_FX
375.          if(iflags.usealleg && botl_warn && !Hallucination)
376.          {
377.              Sprintf(nb = eos(nb), " ");
378.              for(w = 0; w < botl_warn; w++)
379.                  Sprintf(nb = eos(nb), "!");
380.          }
381.  #endif
382.  	        
383.          if (bot2_abbrev >= 2) {
384.  		if (hu_abbrev_stat[u.uhs][0]!='\0') {
385.  			Sprintf(nb = eos(nb), " ");
386.  			Strcat(newbot2, hu_abbrev_stat[u.uhs]);
387.  		}
388.  	}
389.  	else if(strcmp(hu_stat[u.uhs], "        ")) {
390.  		Sprintf(nb = eos(nb), " ");
391.  		Strcat(newbot2, hu_stat[u.uhs]);
392.  	}
393.  
394.  /* WAC further Up
395.  #ifdef SCORE_ON_BOTL
396.  	if (flags.showscore)
397.                  Sprintf(nb,"%c:%-2ld  Score:%ld", oc_syms[COIN_CLASS],
398.                     u.ugold, botl_score());
399.  #endif
400.  */
401.  	/* KMH -- changed to Lev */
402.  	if (Levitation)    Sprintf(nb = eos(nb), " Lev");
403.  	if(Confusion)
404.  		Sprintf(nb = eos(nb), bot2_abbrev >= 2 ? " Cnf" : " Conf");
405.  	if(Sick) {
406.  		if (u.usick_type & SICK_VOMITABLE)
407.  			   Sprintf(nb = eos(nb),
408.  			     bot2_abbrev >= 2 ? " FPs" : " FoodPois");
409.  		if (u.usick_type & SICK_NONVOMITABLE)
410.  			   Sprintf(nb = eos(nb), " Ill");
411.  	}
412.  
413.  	if(Blind)
414.  		Sprintf(nb = eos(nb), bot2_abbrev >= 2 ? " Bnd" : " Blind");
415.  	if(Stunned)
416.  		Sprintf(nb = eos(nb), bot2_abbrev >= 2 ? " Stn" : " Stun");
417.  	if(Hallucination)
418.  		Sprintf(nb = eos(nb), bot2_abbrev >= 2 ? " Hal" : " Hallu");
419.  	if(Slimed)
420.  		Sprintf(nb = eos(nb), bot2_abbrev >= 2 ? " Slm" : " Slime");
421.  	if(u.ustuck && !u.uswallow && !sticks(youmonst.data))
422.  		Sprintf(nb = eos(nb), " Held");
423.  	if(cap > UNENCUMBERED)
424.  		Sprintf(nb = eos(nb), " %s",
425.  		  bot2_abbrev >= 2 ? enc_abbrev_stat[cap] : enc_stat[cap]);
426.  }
427.  
428.  STATIC_OVL void
429.  bot2()
430.  {
431.  	char  newbot2[MAXCO];
432.  
433.  	bot2str(newbot2);
434.  	curs(WIN_STATUS, 1, 1);
435.  
436.  	putstr(WIN_STATUS, 0, newbot2);
437.  	return;
438.  }
439.  
440.  /* WAC -- Shorten bot1 to fit in len spaces.
441.   * Not currently used
442.   * Longest string past Str: is
443.   * ". Str:18/99 Dx:11 Co:13 In:12 Wi:14 Ch:14 Neutral" or 49 Chars long.
444.   */
445.  #if 0
446.  const char*
447.  shorten_bot1(str, len)
448.  const char *str;
449.  int len;
450.  {
451.      static char cbuf[BUFSZ];
452.  
453.      register const char *bp0 = str;
454.      register char *bp1 = cbuf;
455.      int k = 0;
456.  
457.      do {
458.              *bp1++ = *bp0;
459.              k++;
460.      } while(*bp0++ && k < (len - 49));
461.      
462.      cbuf[k] = '.';
463.      bp1++;
464.      
465.      bp0 = index(str, ':') - 3;
466.      do {
467.              *bp1++ = *bp0;
468.      } while(*bp0++);
469.      return cbuf;
470.  }
471.  #endif /* 0 */
472.  
473.  /* ALI -- Shorten bot2 to fit in len spaces.
474.   * Currently only used by tty port
475.   * After the forth attempt the longest practical bot2 becomes:
476.   *      HP:700(700) Pw:111(111) AC:-127 Exp:30
477.   *      Sat Lev Cnf FPs Ill Bnd Stn Hal Slm Old
478.   * -- or just under 80 characters
479.   */
480.  #ifdef TTY_GRAPHICS
481.  const char*
482.  shorten_bot2(str, len)
483.  const char *str;
484.  unsigned int len;
485.  {
486.      static char cbuf[MAXCO];
487.      for(bot2_abbrev = 1; bot2_abbrev <= 4; bot2_abbrev++) {
488.  	bot2str(cbuf);
489.  	if (strlen(cbuf) <= len)
490.  	    break;
491.      }
492.      if (bot2_abbrev > 4)
493.  	cbuf[len] = '\0';	/* If all else fails, truncate the line */
494.      bot2_abbrev = 0;
495.      return cbuf;
496.  }
497.  #endif /* TTY_GRAPHICS */
498.  
499.  static void (*raw_handler)();
500.  
501.  static void bot_raw(reconfig)
502.  boolean reconfig;
503.  {
504.      const char *botl_raw_values[24], **rv = botl_raw_values;
505.      char dex[3], con[3], itl[3], wis[3], cha[3], score[21];
506.      int uhp;
507.      char dlevel[BUFSZ];
508.      char hp[21], hpmax[21], pw[21], pwmax[21], gold[21], ac[21], elevel[21];
509.      char expr[21], iweight[21], capacity[21], flgs[21], tim[21];
510.      *rv++ = reconfig ? "player" : botl_player();
511.      *rv++ = reconfig ? "strength" : botl_strength();
512.      *rv++ = reconfig ? "dexterity" : (Sprintf(dex, "%d", ACURR(A_DEX)), dex);
513.      *rv++ = reconfig ? "constitution" : (Sprintf(con, "%d", ACURR(A_CON)), con);
514.      *rv++ = reconfig ? "intelligence" : (Sprintf(itl, "%d", ACURR(A_INT)), itl);
515.      *rv++ = reconfig ? "wisdom" : (Sprintf(wis, "%d", ACURR(A_WIS)), wis);
516.      *rv++ = reconfig ? "charisma" : (Sprintf(cha, "%d", ACURR(A_CHA)), cha);
517.      *rv++ = reconfig ? "alignment" : u.ualign.type == A_CHAOTIC ? "Chaotic" :
518.  	    u.ualign.type == A_NEUTRAL ? "Neutral" : "Lawful";
519.  #ifdef SCORE_ON_BOTL
520.      if (flags.showscore)
521.  	*rv++ = reconfig ? "score" :
522.  		(Sprintf(score, "%ld", botl_score()), score);
523.  #endif
524.      uhp = Upolyd ? u.mh : u.uhp;
525.      if (uhp < 0) uhp = 0;
526.      (void) describe_level(dlevel, TRUE);
527.      eos(dlevel)[-1] = 0;
528.      *rv++ = reconfig ? "dlevel" : dlevel;
529.      *rv++ = reconfig ? "gold" : (Sprintf(gold, "%ld",
530.  #ifndef GOLDOBJ
531.      u.ugold
532.  #else
533.  	money_cnt(invent)
534.  #endif
535.      ), gold);
536.      *rv++ = reconfig ? "hp" : (Sprintf(hp, "%d", uhp), hp);
537.      *rv++ = reconfig ? "hpmax" :
538.  	    (Sprintf(hpmax, "%d", Upolyd ? u.mhmax : u.uhpmax), hpmax);
539.      *rv++ = reconfig ? "pw" : (Sprintf(pw, "%d", u.uen), pw);
540.      *rv++ = reconfig ? "pwmax" : (Sprintf(pwmax, "%d", u.uenmax), pwmax);
541.      *rv++ = reconfig ? "ac" : (Sprintf(ac, "%d", u.uac), ac);
542.      Sprintf(elevel, "%u",
543.  	    Upolyd && u.ulycn != u.umonnum ? mons[u.umonnum].mlevel : u.ulevel);
544.      *rv++ = reconfig ? (Upolyd ? "hitdice" : "elevel") : elevel;
545.  #ifdef EXP_ON_BOTL
546.      if (flags.showexp)
547.  	*rv++ = reconfig ? "experience" : (Sprintf(expr, "%ld", u.uexp), expr);
548.  #endif
549.  #ifdef SHOW_WEIGHT
550.      if (flags.showweight) {
551.  	*rv++ = reconfig ? "weight" : (Sprintf(iweight,
552.  		"%ld", (long)(inv_weight() + weight_cap())), iweight);
553.  	*rv++ = reconfig ? "capacity" : (Sprintf(capacity,
554.  		"%ld", (long)weight_cap()), capacity);
555.      }
556.  #endif
557.      if (flags.time)
558.  	*rv++ = reconfig ? "time" : (Sprintf(tim, "%ld", moves), tim);
559.      *rv++ = reconfig ? "hunger" : strcmp(hu_stat[u.uhs], "        ") ?
560.  	    hu_stat[u.uhs] : "";
561.      *rv++ = reconfig ? "encumberance" : enc_stat[near_capacity()];
562.      *rv++ = reconfig ? "flags" : (Sprintf(flgs, "%lX",
563.          (Levitation ? RAW_STAT_LEVITATION : 0) |
564.  	(Confusion ? RAW_STAT_CONFUSION : 0) |
565.  	(Sick && (u.usick_type & SICK_VOMITABLE) ? RAW_STAT_FOODPOIS : 0) |
566.  	(Sick && (u.usick_type & SICK_NONVOMITABLE) ? RAW_STAT_ILL : 0) |
567.  	(Blind ? RAW_STAT_BLIND : 0) |
568.  	(Stunned ? RAW_STAT_STUNNED : 0) |
569.  	(Hallucination ? RAW_STAT_HALLUCINATION : 0) |
570.  	(Slimed ? RAW_STAT_SLIMED : 0)), flgs);
571.      (*raw_handler)(reconfig, rv - botl_raw_values, botl_raw_values);
572.  }
573.  
574.  void bot_reconfig()
575.  {
576.      if (raw_handler)
577.  	bot_raw(TRUE);
578.      flags.botl = 1;
579.  }
580.  
581.  void
582.  bot_set_handler(handler)
583.  void (*handler)();
584.  {
585.      raw_handler = handler;
586.      bot_reconfig();
587.  }
588.  
589.  void
590.  bot()
591.  {
592.  	/*
593.  	 * ALI: Cope with the fact that u_init may not have been
594.  	 * called yet. This happens if the player selection menus
595.  	 * are long enough to overwite the status line. In this
596.  	 * case we will be called when the menu is removed while
597.  	 * youmonst.data is still NULL.
598.  	 */
599.  	if (!youmonst.data)
600.  		return;
601.  	if (raw_handler)
602.  		bot_raw(FALSE);
603.  	else {
604.  	bot1();
605.  	bot2();
606.  	}
607.  	flags.botl = flags.botlx = 0;
608.  }
609.  
610.  #endif /* OVL0 */
611.  
612.  /*botl.c*/

Also on Fandom

Random Wiki