![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to util.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / early-roguelike / arogue5|
Return to util.c CVS log | Up to [contributed] / early-roguelike / arogue5 |
1.1 rubenllo 1: /*
2: * all sorts of miscellaneous routines
3: *
4: * Advanced Rogue
5: * Copyright (C) 1984, 1985 Michael Morgan, Ken Dalka and AT&T
6: * All rights reserved.
7: *
8: * Based on "Rogue: Exploring the Dungeons of Doom"
9: * Copyright (C) 1980, 1981 Michael Toy, Ken Arnold and Glenn Wichman
10: * All rights reserved.
11: *
12: * See the file LICENSE.TXT for full copyright and licensing information.
13: */
14:
15: #include "curses.h"
16: #include "rogue.h"
17: #include <ctype.h>
18: #include <string.h>
19:
20: /*
21: * aggravate:
22: * aggravate all the monsters on this level
23: */
24:
25: void
26: aggravate(void)
27: {
28: register struct linked_list *mi;
29:
30: for (mi = mlist; mi != NULL; mi = next(mi))
31: runto(THINGPTR(mi), &hero);
32: }
33:
34: /*
35: * cansee:
36: * returns true if the hero can see a certain coordinate.
37: */
38:
39: bool
40: cansee(int y, int x)
41: {
42: register struct room *rer;
43: register int radius;
44: coord tp;
45:
46: if (on(player, ISBLIND))
47: return FALSE;
48:
49: tp.y = y;
50: tp.x = x;
51: rer = roomin(&tp);
52:
53: /* How far can we see? */
54: if (levtype == OUTSIDE) {
55: if (daytime) radius = 36;
56: else if (lit_room(rer)) radius = 9;
57: else radius = 3;
58: }
59: else radius = 3;
60:
61: /*
62: * We can only see if the hero in the same room as
63: * the coordinate and the room is lit or if it is close.
64: */
65: return ((rer != NULL &&
66: levtype != OUTSIDE &&
67: (levtype != MAZELEV || /* Maze level needs direct line */
68: maze_view(tp.y, tp.x)) &&
69: rer == roomin(&hero) &&
70: lit_room(rer)) ||
71: DISTANCE(y, x, hero.y, hero.x) < radius);
72: }
73:
74: /*
75: * check_level:
76: * Check to see if the guy has gone up a level.
77: *
78: * Return points needed to obtain next level.
79: *
80: * These are the beginning experience levels for all players.
81: * All further experience levels are computed by muliplying by 2
82: * up through MAXDOUBLE.
83: */
84: #define MAXDOUBLE 14 /* Maximum number of times score is doubled */
85: static struct {
86: long base; /* What it starts out at for doubling */
87: long cap; /* The maximum before doubling stops */
88: } e_levels[4] = {
89: /* You must change MAXDOUBLE if you change the cap figure */
90: { 90L, 1474560L }, /* Fighter */
91: { 130L, 2129920L }, /* Magician */
92: { 110L, 1802240L }, /* cleric */
93: { 75L, 1228800L } /* Thief */
94: };
95:
96: long
97: check_level(bool get_spells)
98: {
99: register int i, j, add = 0;
100: register unsigned long exp;
101: long retval; /* Return value */
102: int nsides = 0;
103:
104: /* See if we are past the doubling stage */
105: exp = e_levels[player.t_ctype].cap;
106: if (pstats.s_exp >= exp) {
107: i = pstats.s_exp/exp; /* First get amount above doubling area */
108: retval = exp + i * exp; /* Compute next higher boundary */
109: i += MAXDOUBLE; /* Add in the previous doubled levels */
110: }
111: else {
112: i = 0;
113: exp = e_levels[player.t_ctype].base;
114: while (exp <= pstats.s_exp) {
115: i++;
116: exp <<= 1;
117: }
118: retval = exp;
119: }
120: if (++i > pstats.s_lvl) {
121: switch (player.t_ctype) {
122: case C_FIGHTER: nsides = 10;
123: when C_MAGICIAN: nsides = 4;
124: when C_CLERIC: nsides = 8;
125: when C_THIEF: nsides = 6;
126: }
127:
128: /* Take care of multi-level jumps */
129: for (j=0; j < (i-pstats.s_lvl); j++)
130: add += max(1, roll(1,nsides) + const_bonus());
131: max_stats.s_hpt += add;
132: if ((pstats.s_hpt += add) > max_stats.s_hpt)
133: pstats.s_hpt = max_stats.s_hpt;
134: sprintf(outstring,"Welcome, %s, to level %d",
135: cnames[player.t_ctype][min(i-1, 10)], i);
136: msg(outstring);
137: if (get_spells) {
138: pray_time = 0; /* A new round of prayers */
139: spell_power = 0; /* A new round of spells */
140: }
141: }
142: pstats.s_lvl = i;
143: return(retval);
144: }
145:
146: /*
147: * Used to modify the playes strength
148: * it keeps track of the highest it has been, just in case
149: */
150:
151: void
152: chg_str(int amt)
153: {
154: register int ring_str; /* ring strengths */
155: register struct stats *ptr; /* for speed */
156:
157: ptr = &pstats;
158: ring_str = ring_value(R_ADDSTR);
159: ptr->s_str -= ring_str;
160: ptr->s_str += amt;
161: if (ptr->s_str > 25)
162: ptr->s_str = 25;
163: if (ptr->s_str > max_stats.s_str)
164: max_stats.s_str = ptr->s_str;
165: ptr->s_str += ring_str;
166: if (ptr->s_str <= 0)
167: death(D_STRENGTH);
168: updpack(TRUE);
169: }
170:
171: /*
172: * this routine computes the players current AC without dex bonus's
173: */
174: int
175: ac_compute(void)
176: {
177: register int ac;
178:
179: ac = cur_armor != NULL ? cur_armor->o_ac : pstats.s_arm;
180: ac -= ring_value(R_PROTECT);
181: if (cur_misc[WEAR_BRACERS] != NULL)
182: ac -= cur_misc[WEAR_BRACERS]->o_ac;
183: if (cur_misc[WEAR_CLOAK] != NULL)
184: ac -= cur_misc[WEAR_CLOAK]->o_ac;
185:
186: /* If player has the cloak, must be wearing it */
187: if (cur_relic[EMORI_CLOAK]) ac -= 5;
188:
189: if (ac > 10)
190: ac = 10;
191: return(ac);
192: }
193:
194: /*
195: * this routine computes the players current strength
196: */
197: int
198: str_compute(void)
199: {
200: if (cur_misc[WEAR_GAUNTLET] != NULL &&
201: cur_misc[WEAR_GAUNTLET]->o_which == MM_G_OGRE) {
202: if (cur_misc[WEAR_GAUNTLET]->o_flags & ISCURSED)
203: return (3);
204: else
205: return (18);
206: }
207: else
208: return (pstats.s_str);
209: }
210:
211: /*
212: * this routine computes the players current dexterity
213: */
214: int
215: dex_compute(void)
216: {
217: if (cur_misc[WEAR_GAUNTLET] != NULL &&
218: cur_misc[WEAR_GAUNTLET]->o_which == MM_G_DEXTERITY) {
219: if (cur_misc[WEAR_GAUNTLET]->o_flags & ISCURSED)
220: return (3);
221: else
222: return (18);
223: }
224: else
225: return (pstats.s_dext);
226: }
227:
228:
229: /*
230: * diag_ok:
231: * Check to see if the move is legal if it is diagonal
232: */
233:
234: bool
235: diag_ok(coord *sp, coord *ep, struct thing *flgptr)
236: {
237: register int numpaths = 0;
238:
239: /* Horizontal and vertical moves are always ok */
240: if (ep->x == sp->x || ep->y == sp->y)
241: return TRUE;
242:
243: /* Diagonal moves are not allowed if there is a horizontal or
244: * vertical path to the destination
245: */
246: if (step_ok(ep->y, sp->x, MONSTOK, flgptr)) numpaths++;
247: if (step_ok(sp->y, ep->x, MONSTOK, flgptr)) numpaths++;
248: return(numpaths != 1);
249: }
250:
251: /*
252: * eat:
253: * He wants to eat something, so let him try
254: */
255:
256: void
257: eat(void)
258: {
259: register struct linked_list *item;
260:
261: if ((item = get_item(pack, "eat", FOOD)) == NULL)
262: return;
263: if ((OBJPTR(item))->o_which == 1)
264: msg("My, that was a yummy %s", fruit);
265: else {
266: if (rnd(100) > 70) {
267: msg("Yuk, this food tastes awful");
268:
269: /* Do a check for overflow before increasing experience */
270: if (pstats.s_exp + 1L > pstats.s_exp) pstats.s_exp++;
271: check_level(TRUE);
272: }
273: else
274: msg("Yum, that tasted good");
275: }
276: if ((food_left += HUNGERTIME + rnd(400) - 200) > STOMACHSIZE)
277: food_left = STOMACHSIZE;
278: del_pack(item);
279: hungry_state = F_OKAY;
280: updpack(TRUE);
281: }
282:
283: /*
284: * pick a random position around the give (y, x) coordinates
285: */
286: coord *
287: fallpos(coord *pos, bool be_clear, int range)
288: {
289: register int tried, i, j;
290: register char ch;
291: static coord ret;
292: static short masks[] = {
293: 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x100 };
294:
295: /*
296: * Pick a spot at random centered on the position given by 'pos' and
297: * up to 'range' squares away from 'pos'
298: *
299: * If 'be_clear' is TRUE, the spot must be either FLOOR or PASSAGE
300: * inorder to be considered valid
301: *
302: *
303: * Generate a number from 0 to 8, representing the position to pick.
304: * Note that this DOES include the positon 'pos' itself
305: *
306: * If this position is not valid, mark it as 'tried', and pick another.
307: * Whenever a position is picked that has been tried before,
308: * sequentially find the next untried position. This eliminates costly
309: * random number generation
310: */
311:
312: tried = 0;
313: while( tried != 0x1ff ) {
314: i = rnd(9);
315: while( tried & masks[i] )
316: i = (i + 1) % 9;
317:
318: tried |= masks[i];
319:
320: for( j = 1; j <= range; j++ ) {
321: ret.x = pos->x + j*grid[i].x;
322: ret.y = pos->y + j*grid[i].y;
323:
324: if (ret.x == hero.x && ret.y == hero.y)
325: continue; /* skip the hero */
326:
327: if (ret.x < 0 || ret.x > COLS - 1 ||
328: ret.y < 1 || ret.y > LINES - 3)
329: continue; /* off the screen? */
330:
331: ch = CCHAR( winat(ret.y, ret.x) );
332:
333: /*
334: * Check to make certain the spot is valid
335: */
336: switch( ch ) {
337: case FLOOR:
338: case PASSAGE:
339: return( &ret );
340: case GOLD:
341: case SCROLL:
342: case POTION:
343: case STICK:
344: case RING:
345: case WEAPON:
346: case ARMOR:
347: case MM:
348: case FOOD:
349: if(!be_clear && levtype != POSTLEV)
350: return( &ret );
351: default:
352: break;
353: }
354: }
355: }
356: return( NULL );
357: }
358:
359:
360: /*
361: * find_mons:
362: * Find the monster from his corrdinates
363: */
364:
365: struct linked_list *
366: find_mons(int y, int x)
367: {
368: register struct linked_list *item;
369: register struct thing *th;
370:
371: for (item = mlist; item != NULL; item = next(item))
372: {
373: th = THINGPTR(item);
374: if (th->t_pos.y == y && th->t_pos.x == x)
375: return item;
376: }
377: return NULL;
378: }
379:
380: /*
381: * find_obj:
382: * find the unclaimed object at y, x
383: */
384:
385: struct linked_list *
386: find_obj(int y, int x)
387: {
388: register struct linked_list *obj;
389: register struct object *op;
390:
391: for (obj = lvl_obj; obj != NULL; obj = next(obj))
392: {
393: op = OBJPTR(obj);
394: if (op->o_pos.y == y && op->o_pos.x == x)
395: return obj;
396: }
397: return NULL;
398: }
399:
400:
401: /*
402: * set up the direction co_ordinate for use in varios "prefix" commands
403: */
404: bool
405: get_dir(void)
406: {
407: register char *prompt;
408: register bool gotit;
409:
410: prompt = terse ? "Direction?" : "Which direction? ";
411: msg(prompt);
412: do
413: {
414: gotit = TRUE;
415: switch (readchar())
416: {
417: case 'h': case'H': delta.y = 0; delta.x = -1;
418: when 'j': case'J': delta.y = 1; delta.x = 0;
419: when 'k': case'K': delta.y = -1; delta.x = 0;
420: when 'l': case'L': delta.y = 0; delta.x = 1;
421: when 'y': case'Y': delta.y = -1; delta.x = -1;
422: when 'u': case'U': delta.y = -1; delta.x = 1;
423: when 'b': case'B': delta.y = 1; delta.x = -1;
424: when 'n': case'N': delta.y = 1; delta.x = 1;
425: when ESCAPE: return FALSE;
426: otherwise:
427: mpos = 0;
428: msg(prompt);
429: gotit = FALSE;
430: }
431: } until (gotit);
432: if ((on(player, ISHUH) || on(player, ISDANCE)) && rnd(100) > 20) {
433: do
434: {
435: delta = grid[rnd(9)];
436: } while (delta.y == 0 && delta.x == 0);
437: }
438: mpos = 0;
439: return TRUE;
440: }
441:
442: /*
443: * see if the object is one of the currently used items
444: */
445: bool
446: is_current(struct object *obj)
447: {
448: if (obj == NULL)
449: return FALSE;
450: if (obj == cur_armor || obj == cur_weapon ||
451: obj == cur_ring[LEFT_1] || obj == cur_ring[LEFT_2] ||
452: obj == cur_ring[LEFT_3] || obj == cur_ring[LEFT_4] ||
453: obj == cur_ring[RIGHT_1] || obj == cur_ring[RIGHT_2] ||
454: obj == cur_ring[RIGHT_3] || obj == cur_ring[RIGHT_4] ||
455: obj == cur_misc[WEAR_BOOTS] || obj == cur_misc[WEAR_JEWEL] ||
456: obj == cur_misc[WEAR_BRACERS] || obj == cur_misc[WEAR_CLOAK] ||
457: obj == cur_misc[WEAR_GAUNTLET] || obj == cur_misc[WEAR_NECKLACE]) {
458:
459: return TRUE;
460: }
461:
462: /* Is it a "current" relic? */
463: if (obj->o_type == RELIC) {
464: switch (obj->o_which) {
465: case MUSTY_DAGGER:
466: case EMORI_CLOAK:
467: case HEIL_ANKH:
468: case YENDOR_AMULET:
469: case HRUGGEK_MSTAR:
470: case YEENOGHU_FLAIL:
471: if (cur_relic[obj->o_which]) return TRUE;
472: }
473: }
474:
475: return FALSE;
476: }
477:
478:
479: /*
480: * Look:
481: * A quick glance all around the player
482: * wakeup: Should we wake up monsters
483: * runend: At end of a run -- for mazes
484: */
485:
486: void
487: look(bool wakeup, bool runend)
488: {
489: register int x, y, radius;
490: register char ch, och;
491: register int oldx, oldy;
492: register bool inpass, horiz, vert, do_light = FALSE, do_blank = FALSE;
493: register int passcount = 0, curfloorcount = 0, nextfloorcount = 0;
494: register struct room *rp;
495: register int ey, ex;
496:
497: inpass = ((rp = roomin(&hero)) == NULL); /* Are we in a passage? */
498:
499: /* Are we moving vertically or horizontally? */
500: if (runch == 'h' || runch == 'l') horiz = TRUE;
501: else horiz = FALSE;
502: if (runch == 'j' || runch == 'k') vert = TRUE;
503: else vert = FALSE;
504:
505: /* How far around himself can the player see? */
506: if (levtype == OUTSIDE) {
507: if (daytime) radius = 6;
508: else if (lit_room(rp)) radius = 3;
509: else radius = 1;
510: }
511: else radius = 1;
512:
513: getyx(cw, oldy, oldx); /* Save current position */
514:
515: /* Blank out the floor around our last position and check for
516: * moving out of a corridor in a maze.
517: */
518: if (levtype == OUTSIDE) do_blank = !daytime;
519: else if (oldrp != NULL && !lit_room(oldrp) && off(player, ISBLIND))
520: do_blank = TRUE;
521:
522: /* Now move around the old position and blank things out */
523: ey = player.t_oldpos.y + radius;
524: ex = player.t_oldpos.x + radius;
525: for (x = player.t_oldpos.x - radius; x <= ex; x++)
526: if (x >= 0 && x < COLS)
527: for (y = player.t_oldpos.y - radius; y <= ey; y++) {
528: char savech; /* Saves character in monster window */
529:
530: if (y < 1 || y > LINES - 3) continue;
531:
532: /* See what's there -- ignore monsters, just see what they're on */
533: savech = CCHAR( mvwinch(mw, y, x) );
534: waddch(mw, ' ');
535: ch = show(y, x);
536: mvwaddch(mw, y, x, savech); /* Restore monster */
537:
538: if (do_blank && (y != hero.y || x != hero.x))
539: switch (ch) {
540: case DOOR:
541: case SECRETDOOR:
542: case PASSAGE:
543: case STAIRS:
544: case TRAPDOOR:
545: case TELTRAP:
546: case BEARTRAP:
547: case SLEEPTRAP:
548: case ARROWTRAP:
549: case DARTTRAP:
550: case MAZETRAP:
551: case POOL:
552: case POST:
553: case '|':
554: case '-':
555: case WALL:
556: /* If there was a monster showing, make it disappear */
557: if (isalpha(savech)) mvwaddch(cw, y, x, ch);
558: break;
559: when FLOOR:
560: case FOREST:
561: default:
562: mvwaddch(cw, y, x, ' ');
563: }
564:
565: /* Moving out of a corridor? */
566: if (levtype == MAZELEV && !ce(hero, player.t_oldpos) &&
567: !running && !isrock(ch) && /* Not running and not a wall */
568: ((vert && x != player.t_oldpos.x && y==player.t_oldpos.y) ||
569: (horiz && y != player.t_oldpos.y && x==player.t_oldpos.x)))
570: do_light = off(player, ISBLIND);
571: }
572:
573: /* Take care of unlighting a corridor */
574: if (do_light && lit_room(rp)) light(&player.t_oldpos);
575:
576: /* Are we coming or going between a wall and a corridor in a maze? */
577: och = show(player.t_oldpos.y, player.t_oldpos.x);
578: ch = show(hero.y, hero.x);
579: if (levtype == MAZELEV &&
580: ((isrock(och) && !isrock(ch)) || (isrock(ch) && !isrock(och)))) {
581: do_light = off(player, ISBLIND); /* Light it up if not blind */
582:
583: /* Unlight what we just saw */
584: if (do_light && lit_room(&rooms[0])) light(&player.t_oldpos);
585: }
586:
587: /* Look around the player */
588: ey = hero.y + radius;
589: ex = hero.x + radius;
590: for (x = hero.x - radius; x <= ex; x++)
591: if (x >= 0 && x < COLS) for (y = hero.y - radius; y <= ey; y++) {
592: if (y < 1 || y >= LINES - 2)
593: continue;
594: if (isalpha(mvwinch(mw, y, x)))
595: {
596: register struct linked_list *it;
597: register struct thing *tp;
598:
599: if (wakeup)
600: it = wake_monster(y, x);
601: else
602: it = find_mons(y, x);
603: tp = THINGPTR(it);
604: tp->t_oldch = CCHAR( mvinch(y, x) );
605: if (isatrap(tp->t_oldch)) {
606: register struct trap *trp = trap_at(y, x);
607:
608: tp->t_oldch = (trp->tr_flags & ISFOUND) ? tp->t_oldch
609: : trp->tr_show;
610: }
611: if (tp->t_oldch == FLOOR && !lit_room(rp) &&
612: off(player, ISBLIND))
613: tp->t_oldch = ' ';
614: }
615:
616: /*
617: * Secret doors show as walls
618: */
619: if ((ch = show(y, x)) == SECRETDOOR)
620: ch = secretdoor(y, x);
621: /*
622: * Don't show room walls if he is in a passage and
623: * check for maze turns
624: */
625: if (off(player, ISBLIND))
626: {
627: if (y == hero.y && x == hero.x
628: || (inpass && (ch == '-' || ch == '|')))
629: continue;
630:
631: /* Did we come to a crossroads in a maze? */
632: if (levtype == MAZELEV &&
633: (runend || !ce(hero, player.t_oldpos)) &&
634: !isrock(ch) && /* Not a wall */
635: ((vert && x != hero.x && y == hero.y) ||
636: (horiz && y != hero.y && x == hero.x)))
637: /* Just came to a turn */
638: do_light = off(player, ISBLIND);
639: }
640: else if (y != hero.y || x != hero.x)
641: continue;
642:
643: wmove(cw, y, x);
644: waddch(cw, ch);
645: if (door_stop && !firstmove && running)
646: {
647: switch (runch)
648: {
649: case 'h':
650: if (x == hero.x + 1)
651: continue;
652: when 'j':
653: if (y == hero.y - 1)
654: continue;
655: when 'k':
656: if (y == hero.y + 1)
657: continue;
658: when 'l':
659: if (x == hero.x - 1)
660: continue;
661: when 'y':
662: if ((x + y) - (hero.x + hero.y) >= 1)
663: continue;
664: when 'u':
665: if ((y - x) - (hero.y - hero.x) >= 1)
666: continue;
667: when 'n':
668: if ((x + y) - (hero.x + hero.y) <= -1)
669: continue;
670: when 'b':
671: if ((y - x) - (hero.y - hero.x) <= -1)
672: continue;
673: }
674: switch (ch)
675: {
676: case DOOR:
677: if (x == hero.x || y == hero.y)
678: running = FALSE;
679: break;
680: case PASSAGE:
681: if (x == hero.x || y == hero.y)
682: passcount++;
683: break;
684: case FLOOR:
685: /* Stop by new passages in a maze (floor next to us) */
686: if ((levtype == MAZELEV) &&
687: !(hero.y == y && hero.x == x)) {
688: if (vert) { /* Moving vertically */
689: /* We have a passage on our row */
690: if (y == hero.y) curfloorcount++;
691:
692: /* Some passage on the next row */
693: else if (y != player.t_oldpos.y)
694: nextfloorcount++;
695: }
696: else { /* Moving horizontally */
697: /* We have a passage on our column */
698: if (x == hero.x) curfloorcount++;
699:
700: /* Some passage in the next column */
701: else if (x != player.t_oldpos.x)
702: nextfloorcount++;
703: }
704: }
705: case '|':
706: case '-':
707: case ' ':
708: break;
709: default:
710: running = FALSE;
711: break;
712: }
713: }
714: }
715:
716: /* Have we passed a side passage, with multiple choices? */
717: if (curfloorcount > 0 && nextfloorcount > 0) running = FALSE;
718:
719: else if (door_stop && !firstmove && passcount > 1)
720: running = FALSE;
721:
722: /* Do we have to light up the area (just stepped into a new corridor)? */
723: if (do_light && !running && lit_room(rp)) light(&hero);
724:
725: mvwaddch(cw, hero.y, hero.x, PLAYER);
726: wmove(cw, oldy, oldx);
727: if (!ce(player.t_oldpos, hero)) {
728: player.t_oldpos = hero; /* Don't change if we didn't move */
729: oldrp = rp;
730: }
731: }
732:
733: /*
734: * raise_level:
735: * The guy just magically went up a level.
736: */
737:
738: void
739: raise_level(bool get_spells)
740: {
741: unsigned long test; /* Next level -- be sure it is not an overflow */
742:
743: test = check_level(FALSE); /* Get next boundary */
744:
745: /* Be sure it is higher than what we have no -- else overflow */
746: if (test > pstats.s_exp) pstats.s_exp = test;
747: check_level(get_spells);
748: }
749:
750: /*
751: * saving throw matrix for character saving throws
752: * this table is indexed by char type and saving throw type
753: */
754: static int st_matrix[5][5] = {
755: /* Poison, Petrify, wand, Breath, Magic */
756: { 14, 15, 16, 16, 17 },
757: { 14, 13, 11, 15, 12 },
758: { 10, 13, 14, 16, 15 },
759: { 13, 12, 14, 16, 15 },
760: { 14, 15, 16, 16, 17 }
761: };
762:
763: /*
764: * save:
765: * See if a creature saves against something
766: * which: which type of save
767: * who: who is saving
768: * adj: saving throw adjustment
769: */
770: bool
771: save(int which, struct thing *who, int adj)
772: {
773: register int need, level;
774:
775: level = who->t_stats.s_lvl;
776: need = st_matrix[who->t_ctype][which];
777: switch (who->t_ctype) {
778: case C_FIGHTER:
779: need -= (level-1) / 2;
780: when C_MAGICIAN:
781: need -= 2 * (level-1) / 5;
782: when C_CLERIC:
783: need -= (level-1) / 3;
784: when C_THIEF:
785: need -= 2 * (level-1) / 4;
786: when C_MONSTER:
787: need -= level / 2;
788: }
789: /*
790: * add in pluses against poison for execeptional constitution
791: */
792: if (which == VS_POISON && who->t_stats.s_const > 18)
793: need -= (who->t_stats.s_const - 17) / 2;
794: /*
795: * does the player have a ring of protection on?
796: */
797: if (who == &player)
798: need -= (min(ring_value(R_PROTECT),3)); /* no more than +3 bonus */
799: /*
800: * does the player have a cloak of protection on?
801: */
802: if (who == &player && cur_misc[WEAR_CLOAK])
803: need -= (min(cur_misc[WEAR_CLOAK]->o_ac,3)); /* no more than +3 bonus */
804: need -= adj;
805: debug("need a %d to save", need);
806: return (roll(1, 20) >= need);
807: }
808:
809:
810: /*
811: * secret_door:
812: * Figure out what a secret door looks like.
813: */
814:
815: char
816: secretdoor(int y, int x)
817: {
818: register int i;
819: register struct room *rp;
820: register coord *cpp;
821: static coord cp;
822:
823: cp.y = y;
824: cp.x = x;
825: cpp = &cp;
826: for (rp = rooms, i = 0; i < MAXROOMS; rp++, i++)
827: if (inroom(rp, cpp))
828: if (y == rp->r_pos.y || y == rp->r_pos.y + rp->r_max.y - 1)
829: return('-');
830: else
831: return('|');
832:
833: return('p');
834: }
835:
836: /*
837: * copy string using unctrl for things
838: */
839: void
840: strucpy(char *s1, char *s2, int len)
841: {
842: const char *sp;
843:
844: while (len--)
845: {
846: strcpy(s1, (sp = unctrl(*s2)));
847: s1 += strlen(sp);
848: s2++;
849: }
850: *s1 = '\0';
851: }
852:
853: /*
854: * tr_name:
855: * print the name of a trap
856: */
857:
858: char *
859: tr_name(char ch)
860: {
861: register char *s = NULL;
862:
863: switch (ch)
864: {
865: case TRAPDOOR:
866: s = terse ? "A trapdoor." : "You found a trapdoor.";
867: when BEARTRAP:
868: s = terse ? "A beartrap." : "You found a beartrap.";
869: when SLEEPTRAP:
870: s = terse ? "A sleeping gas trap.":"You found a sleeping gas trap.";
871: when ARROWTRAP:
872: s = terse ? "An arrow trap." : "You found an arrow trap.";
873: when TELTRAP:
874: s = terse ? "A teleport trap." : "You found a teleport trap.";
875: when DARTTRAP:
876: s = terse ? "A dart trap." : "You found a poison dart trap.";
877: when POOL:
878: s = terse ? "A shimmering pool." : "You found a shimmering pool";
879: when MAZETRAP:
880: s = terse ? "A maze entrance." : "You found a maze entrance";
881: }
882: return s;
883: }
884:
885: /*
886: * for printfs: if string starts with a vowel, return "n" for an "an"
887: */
888: char *
889: vowelstr(char *str)
890: {
891: switch (*str)
892: {
893: case 'a':
894: case 'e':
895: case 'i':
896: case 'o':
897: case 'u':
898: return "n";
899: default:
900: return "";
901: }
902: }
903:
904: /*
905: * waste_time:
906: * Do nothing but let other things happen
907: */
908:
909: void
910: waste_time(void)
911: {
912: if (inwhgt) /* if from wghtchk then done */
913: return;
914: do_daemons(BEFORE);
915: do_fuses(BEFORE);
916: do_daemons(AFTER);
917: do_fuses(AFTER);
918: }