![[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 / xrogue|
Return to util.c CVS log | Up to [contributed] / early-roguelike / xrogue |
1.1 rubenllo 1: /*
2: util.c - all sorts of miscellaneous routines
3:
4: XRogue: Expeditions into the Dungeons of Doom
5: Copyright (C) 1991 Robert Pietkivitch
6: All rights reserved.
7:
8: Based on "Advanced Rogue"
9: Copyright (C) 1984, 1985 Michael Morgan, Ken Dalka and AT&T
10: All rights reserved.
11:
12: Based on "Rogue: Exploring the Dungeons of Doom"
13: Copyright (C) 1980, 1981 Michael Toy, Ken Arnold and Glenn Wichman
14: All rights reserved.
15:
16: See the file LICENSE.TXT for full copyright and licensing information.
17: */
18:
19: #include <curses.h>
20: #include <ctype.h>
21: #include <string.h>
22: #include "rogue.h"
23:
24: /*
25: * this routine computes the players current AC without dex bonus's
26: */
27:
28: int
29: ac_compute(bool ignoremetal)
30: {
31: register int ac;
32:
33: ac = pstats.s_arm; /* base armor of "skin" */
34: if (cur_armor) {
35: if (!ignoremetal ||
36: (cur_armor->o_which != LEATHER &&
37: cur_armor->o_which != STUDDED_LEATHER &&
38: cur_armor->o_which != PADDED_ARMOR))
39: ac -= (10 - cur_armor->o_ac);
40: }
41: if (player.t_ctype == C_MONK)
42: ac -= pstats.s_lvl * 3 / 5;
43: ac -= ring_value(R_PROTECT);
44: if (cur_misc[WEAR_BRACERS] != NULL)
45: ac -= cur_misc[WEAR_BRACERS]->o_ac;
46: if (cur_misc[WEAR_CLOAK] != NULL)
47: ac -= cur_misc[WEAR_CLOAK]->o_ac;
48:
49: /* If player has the cloak, must be wearing it */
50: if (cur_relic[EMORI_CLOAK]) ac -= 15;
51:
52: if (ac > 25)
53: ac = 25;
54: return(ac);
55: }
56:
57: /*
58: * aggravate:
59: * aggravate all the monsters on this level
60: */
61:
62: void
63: aggravate(bool do_uniques, bool do_good)
64: {
65: register struct linked_list *mi;
66: register struct thing *thingptr;
67:
68: for (mi = mlist; mi != NULL; mi = next(mi)) {
69: thingptr = THINGPTR(mi);
70: if (do_good == FALSE && off(*thingptr, ISMEAN)) continue;
71: if (do_uniques || off(*thingptr, ISUNIQUE)) runto(thingptr, &hero);
72: }
73: }
74:
75: /*
76: * cansee:
77: * returns true if the hero can see a certain coordinate.
78: */
79:
80: bool
81: cansee(int y, int x)
82: {
83: register struct room *rer;
84: register int radius;
85: coord tp;
86:
87: if (on(player, ISBLIND))
88: return FALSE;
89:
90: tp.y = y;
91: tp.x = x;
92: rer = roomin(&tp);
93:
94: /* How far can we see? */
95: if (levtype == OUTSIDE) {
96: if (daytime) radius = 36;
97: else if (lit_room(rer)) radius = 9;
98: else radius = 3;
99: }
100: else radius = 3;
101:
102: /*
103: * We can only see if the hero in the same room as
104: * the coordinate and the room is lit or if it is close.
105: */
106: return ((rer != NULL &&
107: levtype != OUTSIDE &&
108: (levtype != MAZELEV || /* Maze level needs direct line */
109: maze_view(tp.y, tp.x)) &&
110: rer == roomin(&hero) &&
111: lit_room(rer)) ||
112: DISTANCE(y, x, hero.y, hero.x) < radius);
113: }
114:
115: /*
116: * check_level:
117: * Check to see if the guy has gone up a level.
118: *
119: * Return points needed to obtain next level.
120: *
121: * These are certain beginning experience levels for all players.
122: * All further experience levels are computed by muliplying by 2
123: * up through MAXDOUBLE. Then the cap is added in to compute
124: * further levels
125: */
126:
127: long
128: check_level(void)
129: {
130: register int i, j, add = 0;
131: register unsigned long exp;
132: long retval; /* Return value */
133: int nsides;
134:
135: pstats.s_lvl -= pstats.s_lvladj; /* correct for level adjustment */
136: /* See if we are past the doubling stage */
137: exp = char_class[player.t_ctype].cap;
138: if (pstats.s_exp >= exp) {
139: i = pstats.s_exp/exp; /* First get amount above doubling area */
140: retval = exp + i * exp; /* Compute next higher boundary */
141: i += MAXDOUBLE; /* Add in the previous doubled levels */
142: }
143: else {
144: i = 0;
145: exp = char_class[player.t_ctype].start_exp;
146: while (exp <= pstats.s_exp) {
147: i++;
148: exp <<= 1;
149: }
150: retval = exp;
151: }
152: if (++i > pstats.s_lvl) {
153: nsides = char_class[player.t_ctype].hit_pts;
154: for (j=0; j<(i-pstats.s_lvl); j++) /* Take care of multi-level jumps */
155: add += max(1, roll(1,nsides) + const_bonus());
156: max_stats.s_hpt += add;
157: if ((pstats.s_hpt += add) > max_stats.s_hpt)
158: pstats.s_hpt = max_stats.s_hpt;
159: msg("Welcome, %s, to level %d",
160: cnames[player.t_ctype][min(i-1, NUM_CNAMES-1)], i);
161: }
162: pstats.s_lvl = i;
163: pstats.s_lvl += pstats.s_lvladj; /* correct for level adjustment */
164: return(retval);
165: }
166:
167: /*
168: * Used to modify the players strength
169: * it keeps track of the highest it has been, just in case
170: */
171:
172: void
173: chg_str(int amt)
174: {
175: register int ring_str; /* ring strengths */
176: register struct stats *ptr; /* for speed */
177:
178: ptr = &pstats;
179: ring_str = ring_value(R_ADDSTR);
180: ptr->s_str -= ring_str;
181: ptr->s_str += amt;
182: if (ptr->s_str > MAXATT) ptr->s_str = MAXATT;
183: if (ptr->s_str > max_stats.s_str)
184: max_stats.s_str = ptr->s_str;
185: ptr->s_str += ring_str;
186: if (ptr->s_str <= 0) {
187: pstats.s_hpt = -1;
188: death(D_STRENGTH);
189: }
190: updpack(TRUE, &player);
191: }
192:
193: /*
194: * let's confuse the player
195: */
196:
197: void
198: confus_player(void)
199: {
200: if (off(player, ISCLEAR))
201: {
202: msg("Wait, what's going on here! Huh? What? Who?");
203: if (find_slot(unconfuse))
204: lengthen(unconfuse, HUHDURATION);
205: else
206: fuse(unconfuse, NULL, HUHDURATION, AFTER);
207: turn_on(player, ISHUH);
208: }
209: else msg("You feel dizzy for a moment, but it quickly passes.");
210: }
211:
212: /*
213: * this routine computes the players current dexterity
214: */
215:
216: int
217: dex_compute(void)
218: {
219: if (cur_misc[WEAR_GAUNTLET] != NULL &&
220: cur_misc[WEAR_GAUNTLET]->o_which == MM_G_DEXTERITY) {
221: if (cur_misc[WEAR_GAUNTLET]->o_flags & ISCURSED)
222: return (3);
223: else
224: return (21);
225: }
226: else
227: return (pstats.s_dext);
228: }
229:
230: /*
231: * diag_ok:
232: * Check to see if the move is legal if it is diagonal
233: */
234:
235: bool
236: diag_ok(coord *sp, coord *ep, struct thing *flgptr)
237: {
238: register int numpaths = 0;
239:
240: /* Horizontal and vertical moves are always ok */
241: if (ep->x == sp->x || ep->y == sp->y)
242: return TRUE;
243:
244: /* Diagonal moves are not allowed if there is a horizontal or
245: * vertical path to the destination
246: */
247: if (step_ok(ep->y, sp->x, MONSTOK, flgptr)) numpaths++;
248: if (step_ok(sp->y, ep->x, MONSTOK, flgptr)) numpaths++;
249: return(numpaths != 1);
250: }
251:
252: /*
253: * pick a random position around the give (y, x) coordinates
254: */
255:
256: coord *
257: fallpos(coord *pos, bool be_clear, int range)
258: {
259: register int tried, i, j;
260: register char ch;
261: static coord ret;
262: static short masks[] = {
263: 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x100 };
264:
265: /*
266: * Pick a spot at random centered on the position given by 'pos' and
267: * up to 'range' squares away from 'pos'
268: *
269: * If 'be_clear' is TRUE, the spot must be either FLOOR or PASSAGE
270: * inorder to be considered valid
271: *
272: * Generate a number from 0 to 8, representing the position to pick.
273: * Note that this DOES include the positon 'pos' itself
274: *
275: * If this position is not valid, mark it as 'tried', and pick another.
276: * Whenever a position is picked that has been tried before,
277: * sequentially find the next untried position. This eliminates costly
278: * random number generation
279: */
280:
281: tried = 0;
282: while( tried != 0x1ff ) {
283: i = rnd(9);
284: while( tried & masks[i] )
285: i = (i + 1) % 9;
286:
287: tried |= masks[i];
288:
289: for( j = 1; j <= range; j++ ) {
290: ret.x = pos->x + j*grid[i].x;
291: ret.y = pos->y + j*grid[i].y;
292:
293: if (ret.x == hero.x && ret.y == hero.y)
294: continue; /* skip the hero */
295:
296: if (ret.x < 0 || ret.x > cols - 1 ||
297: ret.y < 1 || ret.y > lines - 3)
298: continue; /* off the screen? */
299:
300: ch = winat(ret.y, ret.x);
301:
302: /*
303: * Check to make certain the spot is valid
304: */
305: switch( ch ) {
306: case FLOOR:
307: case PASSAGE:
308: return( &ret );
309: case GOLD:
310: case SCROLL:
311: case POTION:
312: case STICK:
313: case RING:
314: case WEAPON:
315: case ARMOR:
316: case MM:
317: case FOOD:
318: if(!be_clear && levtype != POSTLEV)
319: return( &ret );
320: default:
321: break;
322: }
323: }
324: }
325: return( NULL );
326: }
327:
328: /*
329: * findmindex:
330: * Find the index into the monster table of a monster given its name.
331: */
332:
333: int
334: findmindex(char *name)
335: {
336: int which;
337:
338: for (which=1; which<NUMMONST; which++) {
339: if (strcmp(name, monsters[which].m_name) == 0)
340: break;
341: }
342: if (which >= NUMMONST) {
343: debug("couldn't find monster index");
344: which = 1;
345: }
346: return(which);
347: }
348:
349: /*
350: * find_mons:
351: * Find the monster from his coordinates
352: */
353:
354: struct linked_list *
355: find_mons(int y, int x)
356: {
357: register struct linked_list *item;
358: register struct thing *th;
359:
360: for (item = mlist; item != NULL; item = next(item))
361: {
362: th = THINGPTR(item);
363: if (th->t_pos.y == y && th->t_pos.x == x)
364: return item;
365: }
366: return NULL;
367: }
368:
369: /*
370: * find_obj:
371: * find the unclaimed object at y, x
372: */
373:
374: struct linked_list *
375: find_obj(int y, int x)
376: {
377: register struct linked_list *obj;
378: register struct object *op;
379:
380: for (obj = lvl_obj; obj != NULL; obj = next(obj))
381: {
382: op = OBJPTR(obj);
383: if (op->o_pos.y == y && op->o_pos.x == x)
384: return obj;
385: }
386: return NULL;
387: }
388:
389: /*
390: * get coordinates from the player using the cursor keys (or mouse)
391: */
392:
393: coord
394: get_coordinates(void)
395: {
396: register int which;
397: coord c;
398:
399: c = hero;
400: wmove(cw, hero.y, hero.x);
401: draw(cw);
402: for (;;) {
403: which = (wgetch(cw) & 0177);
404: switch(which) {
405: case ESC:
406: c = hero;
407: wmove(cw, c.y, c.x);
408: draw(cw);
409: case '\n':
410: case '\r':
411: return(c);
412: when 'h':
413: case 'H':
414: c.x--;
415: when 'j':
416: case 'J':
417: c.y++;
418: when 'k':
419: case 'K':
420: c.y--;
421: when 'l':
422: case 'L':
423: c.x++;
424: when 'y':
425: case 'Y':
426: c.x--; c.y--;
427: when 'u':
428: case 'U':
429: c.x++; c.y--;
430: when 'b':
431: case 'B':
432: c.x--; c.y++;
433: when 'n':
434: case 'N':
435: c.x++; c.y++;
436: when '*':
437: mpos = 0;
438: msg("Use h,j,k,l,y,u,b,n to position cursor, then press enter.");
439: }
440: c.y = max(c.y, 1);
441: c.y = min(c.y, lines - 3);
442: c.x = max(c.x, 0);
443: c.x = min(c.x, cols - 1);
444: wmove(cw, c.y, c.x);
445: draw(cw);
446: }
447: }
448:
449: /*
450: * set up the direction co_ordinate for use in various "prefix" commands
451: */
452:
453: bool
454: get_dir(coord *direction)
455: {
456: register char *prompt;
457: register bool gotit;
458: int x,y;
459:
460: prompt = terse ? "Direction?" : "Which direction? ";
461: msg(prompt);
462: do
463: {
464: gotit = TRUE;
465: switch (wgetch(msgw))
466: {
467: case 'h': case'H': direction->y = 0; direction->x = -1;
468: when 'j': case'J': direction->y = 1; direction->x = 0;
469: when 'k': case'K': direction->y = -1; direction->x = 0;
470: when 'l': case'L': direction->y = 0; direction->x = 1;
471: when 'y': case'Y': direction->y = -1; direction->x = -1;
472: when 'u': case'U': direction->y = -1; direction->x = 1;
473: when 'b': case'B': direction->y = 1; direction->x = -1;
474: when 'n': case'N': direction->y = 1; direction->x = 1;
475: when ESC: return (FALSE);
476: otherwise:
477: mpos = 0;
478: msg(prompt);
479: gotit = FALSE;
480: }
481: } until (gotit);
482: if ((on(player, ISHUH) || on(player, ISDANCE)) && rnd(100) > 20) {
483: do
484: {
485: *direction = grid[rnd(9)];
486: } while (direction->y == 0 && direction->x == 0);
487: }
488: else if (on(player, ISFLEE)) {
489: y = hero.y;
490: x = hero.x;
491: while (shoot_ok(winat(y, x))) {
492: y += direction->y;
493: x += direction->x;
494: }
495: if (isalpha(mvwinch(mw, y, x))) {
496: if (y == player.t_dest->y && x == player.t_dest->x) {
497: mpos = 0;
498: msg("You are too frightened to!");
499: return(FALSE);
500: }
501: }
502: }
503: mpos = 0;
504: return TRUE;
505: }
506:
507:
508: /*
509: * get_worth:
510: * Calculate an objects worth in gold
511: */
512:
513: long
514: get_worth(struct object *obj)
515: {
516: reg long worth, wh;
517:
518: worth = 0;
519: wh = obj->o_which;
520: switch (obj->o_type) {
521: case FOOD:
522: worth = 2;
523: when WEAPON:
524: if (wh < MAXWEAPONS) {
525: worth = weaps[wh].w_worth;
526: worth += s_magic[S_ALLENCH].mi_worth *
527: (obj->o_hplus + obj->o_dplus);
528: }
529: when ARMOR:
530: if (wh < MAXARMORS) {
531: worth = armors[wh].a_worth;
532: worth += s_magic[S_ALLENCH].mi_worth *
533: (armors[wh].a_class - obj->o_ac);
534: }
535: when SCROLL:
536: if (wh < MAXSCROLLS)
537: worth = s_magic[wh].mi_worth;
538: when POTION:
539: if (wh < MAXPOTIONS)
540: worth = p_magic[wh].mi_worth;
541: when RING:
542: if (wh < MAXRINGS) {
543: worth = r_magic[wh].mi_worth;
544: worth += obj->o_ac * 40;
545: }
546: when STICK:
547: if (wh < MAXSTICKS) {
548: worth = ws_magic[wh].mi_worth;
549: worth += 20 * obj->o_charges;
550: }
551: when MM:
552: if (wh < MAXMM) {
553: worth = m_magic[wh].mi_worth;
554: switch (wh) {
555: case MM_BRACERS: worth += 40 * obj->o_ac;
556: when MM_PROTECT: worth += 60 * obj->o_ac;
557: when MM_DISP: /* ac already figured in price*/
558: otherwise: worth += 20 * obj->o_ac;
559: }
560: }
561: when RELIC:
562: if (wh < MAXRELIC) {
563: worth = rel_magic[wh].mi_worth;
564: if (wh == quest_item) worth *= 10;
565: }
566: otherwise:
567: worth = 0;
568: }
569: if (obj->o_flags & ISPROT) /* 300% more for protected */
570: worth *= 3;
571: if (obj->o_flags & ISBLESSED) /* 50% more for blessed */
572: worth = worth * 3 / 2;
573: if (obj->o_flags & ISCURSED) /* half for cursed */
574: worth /= 2;
575: if (worth < 0)
576: worth = 0;
577: return worth;
578: }
579:
580: /*
581: * invisible()
582: */
583:
584: bool
585: invisible(struct thing *monst)
586: {
587: register bool ret_code;
588:
589: ret_code = on(*monst, CANSURPRISE);
590: ret_code &= !ISWEARING(R_ALERT);
591: ret_code |= (on(*monst, ISINVIS) ||
592: (on(*monst, ISSHADOW) && rnd(100) < 90)) &&
593: off(player, CANSEE);
594: return( ret_code );
595: }
596:
597: /*
598: * see if the object is one of the currently used items
599: */
600:
601: bool
602: is_current(struct object *obj)
603: {
604: if (obj == NULL)
605: return FALSE;
606: if (obj == cur_armor || obj == cur_weapon ||
607: obj == cur_ring[LEFT_1] || obj == cur_ring[LEFT_2] ||
608: obj == cur_ring[LEFT_3] || obj == cur_ring[LEFT_4] ||
609: obj == cur_ring[RIGHT_1] || obj == cur_ring[RIGHT_2] ||
610: obj == cur_ring[RIGHT_3] || obj == cur_ring[RIGHT_4] ||
611: obj == cur_misc[WEAR_BOOTS] || obj == cur_misc[WEAR_JEWEL] ||
612: obj == cur_misc[WEAR_BRACERS] || obj == cur_misc[WEAR_CLOAK] ||
613: obj == cur_misc[WEAR_GAUNTLET] || obj == cur_misc[WEAR_NECKLACE]) {
614:
615: return TRUE;
616: }
617:
618: /* Is it a "current" relic? */
619: if (obj->o_type == RELIC) {
620: switch (obj->o_which) {
621: case MUSTY_DAGGER:
622: case EMORI_CLOAK:
623: case HEIL_ANKH:
624: case YENDOR_AMULET:
625: case STONEBONES_AMULET:
626: case HRUGGEK_MSTAR:
627: case AXE_AKLAD:
628: case YEENOGHU_FLAIL:
629: case SURTUR_RING:
630: if (cur_relic[obj->o_which]) return TRUE;
631: }
632: }
633:
634: return FALSE;
635: }
636:
637:
638: /*
639: * Look:
640: * A quick glance all around the player
641: * wakeup: Should we wake up monsters
642: * runend: At end of a run -- for mazes
643: */
644:
645: void
646: look(bool wakeup, bool runend)
647: {
648: register int x, y, radius;
649: register unsigned char ch, och;
650: register int oldx, oldy;
651: register bool inpass, horiz, vert, do_light = FALSE, do_blank = FALSE;
652: register int passcount = 0, curfloorcount = 0, nextfloorcount = 0;
653: register struct room *rp;
654: register int ey, ex;
655:
656: inpass = ((rp = roomin(&hero)) == NULL); /* Are we in a passage? */
657:
658: /* Are we moving vertically or horizontally? */
659: if (runch == 'h' || runch == 'l') horiz = TRUE;
660: else horiz = FALSE;
661: if (runch == 'j' || runch == 'k') vert = TRUE;
662: else vert = FALSE;
663:
664: /* How far around himself can the player see? */
665: if (levtype == OUTSIDE) {
666: if (daytime) radius = 9;
667: else if (lit_room(rp)) radius = 3;
668: else radius = 1;
669: }
670: else radius = 1;
671:
672: getyx(cw, oldy, oldx); /* Save current position */
673:
674: /* Blank out the floor around our last position and check for
675: * moving out of a corridor in a maze.
676: */
677: if (levtype == OUTSIDE) do_blank = !daytime;
678: else if (oldrp != NULL && !lit_room(oldrp) && off(player, ISBLIND))
679: do_blank = TRUE;
680:
681: /* Now move around the old position and blank things out */
682: ey = player.t_oldpos.y + radius;
683: ex = player.t_oldpos.x + radius;
684: for (x = player.t_oldpos.x - radius; x <= ex; x++)
685: if (x >= 0 && x < cols)
686: for (y = player.t_oldpos.y - radius; y <= ey; y++) {
687: struct linked_list *it;
688: coord here; /* Current <x,y> coordinate */
689: unsigned char savech; /* Saves character in monster window */
690: bool in_room; /* Are we in a room? */
691:
692: if (y < 1 || y > lines - 3) continue;
693:
694: /* See what's there -- ignore monsters, just see what they're on */
695: savech = mvwinch(mw, y, x);
696: waddch(mw, ' ');
697: ch = show(y, x);
698: mvwaddch(mw, y, x, savech); /* Restore monster */
699:
700: /*
701: * If we have a monster that we can't see anymore, make sure
702: * that we can note that fact.
703: */
704: if (isalpha(savech) &&
705: (y < hero.y - radius || y > hero.y + radius ||
706: x < hero.x - radius || x > hero.x + radius)) {
707: /* Find the monster */
708: it = find_mons(y, x);
709: }
710: else it = NULL;
711:
712: /* Are we in a room? */
713: here.y = y;
714: here.x = x;
715: in_room = (roomin(&here) != NULL);
716:
717: if ((do_blank || !in_room) && (y != hero.y || x != hero.x))
718: switch (ch) {
719: case DOOR:
720: case SECRETDOOR:
721: case PASSAGE:
722: case STAIRS:
723: case TRAPDOOR:
724: case TELTRAP:
725: case BEARTRAP:
726: case SLEEPTRAP:
727: case ARROWTRAP:
728: case DARTTRAP:
729: case WORMHOLE:
730: case MAZETRAP:
731: case POOL:
732: case POST:
733: case VERTWALL:
734: case HORZWALL:
735: case WALL:
736: /* If there was a monster showing, make it disappear */
737: if (isalpha(savech)) {
738: mvwaddch(cw, y, x, ch);
739:
740: /*
741: * If we found it (we should!), set it to
742: * the right character!
743: */
744: if (it) (THINGPTR(it))->t_oldch = ch;
745: }
746: break;
747: when FLOOR:
748: case FOREST:
749: default:
750: mvwaddch(cw, y, x, in_room ? ' ' : PASSAGE);
751:
752: /* If we found a monster, set it to darkness! */
753: if (it) (THINGPTR(it))->t_oldch = mvwinch(cw, y, x);
754: }
755:
756: /* Moving out of a corridor? */
757: if (levtype == MAZELEV && !ce(hero, player.t_oldpos) &&
758: !running && !isrock(ch) && /* Not running and not a wall */
759: ((vert && x != player.t_oldpos.x && y==player.t_oldpos.y) ||
760: (horiz && y != player.t_oldpos.y && x==player.t_oldpos.x)))
761: do_light = off(player, ISBLIND);
762: }
763:
764: /* Take care of unlighting a corridor */
765: if (do_light && lit_room(rp)) light(&player.t_oldpos);
766:
767: /* Are we coming or going between a wall and a corridor in a maze? */
768: och = show(player.t_oldpos.y, player.t_oldpos.x);
769: ch = show(hero.y, hero.x);
770: if (levtype == MAZELEV &&
771: ((isrock(och) && !isrock(ch)) || (isrock(ch) && !isrock(och)))) {
772: do_light = off(player, ISBLIND); /* Light it up if not blind */
773:
774: /* Unlight what we just saw */
775: if (do_light && lit_room(&rooms[0])) light(&player.t_oldpos);
776: }
777:
778: /* Look around the player */
779: ey = hero.y + radius;
780: ex = hero.x + radius;
781: for (x = hero.x - radius; x <= ex; x++)
782: if (x >= 0 && x < cols) for (y = hero.y - radius; y <= ey; y++) {
783: if (y < 1 || y >= lines - 2)
784: continue;
785: if (isalpha(mvwinch(mw, y, x)))
786: {
787: register struct linked_list *it;
788: register struct thing *tp;
789:
790: if (wakeup)
791: it = wake_monster(y, x);
792: else
793: it = find_mons(y, x);
794:
795: if (it) {
796: tp = THINGPTR(it);
797: tp->t_oldch = mvinch(y, x);
798: if (isatrap(tp->t_oldch)) {
799: register struct trap *trp = trap_at(y, x);
800:
801: tp->t_oldch = (trp->tr_flags & ISFOUND) ? tp->t_oldch
802: : trp->tr_show;
803: }
804: if (tp->t_oldch == FLOOR && !lit_room(rp) &&
805: off(player, ISBLIND))
806: tp->t_oldch = ' ';
807: }
808: }
809:
810: /*
811: * Secret doors show as walls
812: */
813: if ((ch = show(y, x)) == SECRETDOOR)
814: ch = secretdoor(y, x);
815: /*
816: * Don't show room walls if he is in a passage and
817: * check for maze turns
818: */
819: if (off(player, ISBLIND))
820: {
821: if (y == hero.y && x == hero.x
822: || (inpass && (ch == HORZWALL || ch == VERTWALL)))
823: continue;
824:
825: /* Did we come to a crossroads in a maze? */
826: if (levtype == MAZELEV &&
827: (runend || !ce(hero, player.t_oldpos)) &&
828: !isrock(ch) && /* Not a wall */
829: ((vert && x != hero.x && y == hero.y) ||
830: (horiz && y != hero.y && x == hero.x)))
831: /* Just came to a turn */
832: do_light = off(player, ISBLIND);
833: }
834: else if (y != hero.y || x != hero.x)
835: continue;
836:
837: wmove(cw, y, x);
838: waddch(cw, ch);
839: if (door_stop && !firstmove && running)
840: {
841: switch (runch)
842: {
843: case 'h':
844: if (x == hero.x + 1)
845: continue;
846: when 'j':
847: if (y == hero.y - 1)
848: continue;
849: when 'k':
850: if (y == hero.y + 1)
851: continue;
852: when 'l':
853: if (x == hero.x - 1)
854: continue;
855: when 'y':
856: if ((x + y) - (hero.x + hero.y) >= 1)
857: continue;
858: when 'u':
859: if ((y - x) - (hero.y - hero.x) >= 1)
860: continue;
861: when 'n':
862: if ((x + y) - (hero.x + hero.y) <= -1)
863: continue;
864: when 'b':
865: if ((y - x) - (hero.y - hero.x) <= -1)
866: continue;
867: }
868: switch (ch)
869: {
870: case DOOR:
871: if (x == hero.x || y == hero.y)
872: running = FALSE;
873: break;
874: case PASSAGE:
875: if (x == hero.x || y == hero.y)
876: passcount++;
877: break;
878: case FLOOR:
879: /* Stop by new passages in a maze (floor next to us) */
880: if ((levtype == MAZELEV) &&
881: !(hero.y == y && hero.x == x)) {
882: if (vert) { /* Moving vertically */
883: /* We have a passage on our row */
884: if (y == hero.y) curfloorcount++;
885:
886: /* Some passage on the next row */
887: else if (y != player.t_oldpos.y)
888: nextfloorcount++;
889: }
890: else { /* Moving horizontally */
891: /* We have a passage on our column */
892: if (x == hero.x) curfloorcount++;
893:
894: /* Some passage in the next column */
895: else if (x != player.t_oldpos.x)
896: nextfloorcount++;
897: }
898: }
899: case VERTWALL:
900: case HORZWALL:
901: case ' ':
902: break;
903: default:
904: running = FALSE;
905: break;
906: }
907: }
908: }
909:
910: /* Have we passed a side passage, with multiple choices? */
911: if (curfloorcount > 0 && nextfloorcount > 0) running = FALSE;
912:
913: else if (door_stop && !firstmove && passcount > 1)
914: running = FALSE;
915:
916: /* Do we have to light up the area (just stepped into a new corridor)? */
917: if (do_light && !running && lit_room(rp)) light(&hero);
918:
919: mvwaddch(cw, hero.y, hero.x, PLAYER);
920: wmove(cw, oldy, oldx);
921: if (!ce(player.t_oldpos, hero)) {
922: player.t_oldpos = hero; /* Don't change if we didn't move */
923: oldrp = rp;
924: }
925: }
926:
927: /*
928: * Lower a level of experience
929: */
930:
931: void
932: lower_level(short who)
933: {
934: int fewer, nsides;
935: unsigned long exp;
936:
937: msg("You suddenly feel less skillful.");
938: if (--pstats.s_lvl == 0) {
939: pstats.s_hpt = -1;
940: death(who); /* All levels gone */
941: }
942: if (pstats.s_lvladj > 0) { /* lose artificial levels first */
943: pstats.s_lvladj--;
944: return;
945: }
946: exp = char_class[player.t_ctype].cap;
947: if (pstats.s_exp >= exp*2)
948: pstats.s_exp -= exp;
949: else
950: pstats.s_exp /= 2;
951:
952: nsides = char_class[player.t_ctype].hit_pts;
953: fewer = max(1, roll(1,nsides) + const_bonus());
954: pstats.s_hpt -= fewer;
955: max_stats.s_hpt -= fewer;
956: if (max_stats.s_hpt <= 0)
957: max_stats.s_hpt = 0;
958: if (pstats.s_hpt <= 0) {
959: pstats.s_hpt = -1;
960: death(who);
961: }
962: }
963:
964: /*
965: * print out the name of a monster
966: */
967:
968: char *
969: monster_name(struct thing *tp)
970: {
971: prbuf[0] = '\0';
972: if (on(*tp, ISFLEE) || on(*tp, WASTURNED))
973: strcat(prbuf, "terrified ");
974: if (on(*tp, ISHUH))
975: strcat(prbuf, "confused ");
976: if (on(*tp, ISCHARMED))
977: strcat(prbuf, "charmed ");
978: else if (on(*tp, ISFLY))
979: strcat(prbuf, "flying ");
980:
981: /* If it is sleeping or stoned, write over any of the above attributes */
982: if (off(*tp, ISRUN))
983: strcpy(prbuf, "sleeping ");
984: if (on(*tp, ISSTONE))
985: strcpy(prbuf, "petrified ");
986:
987: if (tp->t_name) strcat(prbuf, tp->t_name);
988: else strcat(prbuf, monsters[tp->t_index].m_name);
989:
990: return(prbuf);
991: }
992:
993: /*
994: * move_hero:
995: * Try to move the hero somplace besides next to where he is. We ask him
996: * where. There can be restrictions based on why he is moving.
997: */
998:
999: bool
1000: move_hero(int why)
1001: {
1002: char *action = NULL;
1003: unsigned char which;
1004: coord c;
1005:
1006: switch (why) {
1007: case H_TELEPORT:
1008: action = "teleport";
1009: }
1010:
1011: msg("Where do you wish to %s to? (* for help) ", action);
1012: c = get_coordinates();
1013: mpos = 0;
1014: which = winat(c.y, c.x);
1015: switch (which) {
1016: default:
1017: if (!isrock(which) || off(player, CANINWALL)) break;
1018:
1019: case FLOOR:
1020: case PASSAGE:
1021: case DOOR:
1022: case STAIRS:
1023: case POST:
1024: case GOLD:
1025: case POTION:
1026: case SCROLL:
1027: case FOOD:
1028: case WEAPON:
1029: case ARMOR:
1030: case RING:
1031: case MM:
1032: case RELIC:
1033: case STICK:
1034: hero = c;
1035: return(TRUE);
1036: }
1037: return(FALSE);
1038: }
1039:
1040: /*
1041: * raise_level:
1042: * The guy just magically went up a level.
1043: */
1044:
1045: void
1046: raise_level(void)
1047: {
1048: unsigned long test; /* Next level -- be sure it is not an overflow */
1049:
1050: test = check_level(); /* Get next boundary */
1051:
1052: /* Be sure it is higher than what we have no -- else overflow */
1053: if (test > pstats.s_exp) pstats.s_exp = test;
1054: check_level();
1055:
1056: /* Give him a bonus */
1057: switch (player.t_ctype) {
1058: case C_FIGHTER:
1059: (*add_abil[A_STRENGTH])(1);
1060: when C_RANGER:
1061: case C_PALADIN:
1062: (*add_abil[A_CHARISMA])(1);
1063: when C_MAGICIAN:
1064: (*add_abil[A_INTELLIGENCE])(1);
1065: when C_CLERIC:
1066: case C_DRUID:
1067: (*add_abil[A_WISDOM])(1);
1068: when C_THIEF:
1069: case C_ASSASSIN:
1070: (*add_abil[A_DEXTERITY])(1);
1071: when C_MONK:
1072: (*add_abil[A_CONSTITUTION])(1);
1073: }
1074: }
1075:
1076: /*
1077: * saving throw matrix for character saving throws
1078: * this table is indexed by char type and saving throw type
1079: */
1080:
1081: static const char st_matrix[NUM_CHARTYPES][5] = {
1082: /* Poison, Petrify, wand, Breath, Magic */
1083: { 13, 14, 15, 16, 17 },
1084: { 13, 14, 15, 16, 17 },
1085: { 13, 14, 15, 16, 17 },
1086: { 11, 12, 13, 14, 15 },
1087: { 11, 12, 13, 14, 15 },
1088: { 12, 13, 14, 15, 16 },
1089: { 12, 13, 14, 15, 16 },
1090: { 11, 12, 12, 14, 15 },
1091: { 12, 13, 14, 15, 16 },
1092: { 13, 14, 15, 16, 17 }
1093: };
1094:
1095: /*
1096: * save:
1097: * See if a creature saves against something
1098: * which: which type of save
1099: * who: who is saving
1100: * adj: saving throw adjustment
1101: */
1102:
1103: bool
1104: save(int which, struct thing *who, int adj)
1105: {
1106: register int need, level, protect;
1107:
1108: protect = 0;
1109: level = who->t_stats.s_lvl;
1110: need = st_matrix[who->t_ctype][which];
1111: switch (who->t_ctype) {
1112: case C_FIGHTER:
1113: case C_RANGER:
1114: case C_PALADIN:
1115: need -= (2 * (level-1) / 5) - 1; /* for level 61; -= 25 */
1116: when C_THIEF:
1117: case C_ASSASSIN:
1118: case C_MONK:
1119: case C_MONSTER:
1120: need -= (2 * (level-1) / 5) - 3; /* for level 61; -= 27 */
1121: when C_MAGICIAN:
1122: case C_CLERIC:
1123: case C_DRUID:
1124: need -= (2 * (level-1) / 5) - 5; /* for level 61; -= 29 */
1125: }
1126: /*
1127: * add in pluses against poison for execeptional constitution
1128: */
1129: if (which == VS_POISON && who->t_stats.s_const > 18)
1130: need -= (who->t_stats.s_const - 17) / 2;
1131: if (who == &player) {
1132: /*
1133: * does the player have a ring of protection on?
1134: */
1135: protect += ring_value(R_PROTECT);
1136: /*
1137: * does the player have a cloak of protection on?
1138: */
1139: if (cur_misc[WEAR_CLOAK])
1140: protect += cur_misc[WEAR_CLOAK]->o_ac;
1141:
1142: protect = min(protect, 10);/* limit protection to +10 */
1143: need -= protect;
1144: }
1145: need -= adj;
1146: /*
1147: * always miss or save on a 1 (except for UNIQUEs
1148: */
1149: if (who == &player || off(*who, ISUNIQUE))
1150: need = max(need, 2);
1151: need = min(20, need); /* always make our save on a 20 */
1152: debug("need a %d to save", need);
1153: return (roll(1, 20) >= need);
1154: }
1155:
1156: /*
1157: * secret_door:
1158: * Figure out what a secret door looks like.
1159: */
1160:
1161: char
1162: secretdoor(int y, int x)
1163: {
1164: register int i;
1165: register struct room *rp;
1166: register coord *cpp;
1167: static coord cp;
1168:
1169: cp.y = y;
1170: cp.x = x;
1171: cpp = &cp;
1172: for (rp = rooms, i = 0; i < MAXROOMS; rp++, i++)
1173: if (inroom(rp, cpp))
1174: if (y == rp->r_pos.y || y == rp->r_pos.y + rp->r_max.y - 1)
1175: return(HORZWALL);
1176: else
1177: return(VERTWALL);
1178:
1179: return('p');
1180: }
1181:
1182: /*
1183: * this routine computes the players current strength
1184: */
1185:
1186: int
1187: str_compute(void)
1188: {
1189: if (cur_misc[WEAR_GAUNTLET] != NULL &&
1190: cur_misc[WEAR_GAUNTLET]->o_which == MM_G_OGRE) {
1191: if (cur_misc[WEAR_GAUNTLET]->o_flags & ISCURSED)
1192: return (3);
1193: else
1194: return (21);
1195: }
1196: else
1197: return (pstats.s_str);
1198: }
1199:
1200: /*
1201: * copy string using unctrl for things
1202: */
1203:
1204: void
1205: strucpy(char *s1, char *s2, int len)
1206: {
1207: const char *sp;
1208: while (len--)
1209: {
1210: strcpy(s1, (sp = unctrl(*s2)));
1211: s1 += strlen(sp);
1212: s2++;
1213: }
1214: *s1 = '\0';
1215: }
1216:
1217: /*
1218: * tr_name:
1219: * print the name of a trap
1220: */
1221:
1222: char *
1223: tr_name(char ch)
1224: {
1225: register char *s = NULL;
1226:
1227: switch (ch)
1228: {
1229: case TRAPDOOR:
1230: s = terse ? "A trapdoor." : "You found a trapdoor.";
1231: when BEARTRAP:
1232: s = terse ? "A beartrap." : "You found a beartrap.";
1233: when SLEEPTRAP:
1234: s = terse ? "A sleeping gas trap.":"You found a sleeping gas trap.";
1235: when ARROWTRAP:
1236: s = terse ? "An arrow trap." : "You found an arrow trap.";
1237: when TELTRAP:
1238: s = terse ? "A teleport trap." : "You found a teleport trap.";
1239: when DARTTRAP:
1240: s = terse ? "A dart trap." : "You found a poison dart trap.";
1241: when POOL:
1242: s = terse ? "A shimmering pool." : "You found a shimmering pool";
1243: when MAZETRAP:
1244: s = terse ? "A maze entrance." : "You found a maze entrance";
1245: when WORMHOLE:
1246: s = terse ? "A worm hole." : "You found a worm hole entrance";
1247: }
1248: return s;
1249: }
1250:
1251: /*
1252: * for printfs: if string starts with a vowel, return "n" for an "an"
1253: */
1254:
1255: char *
1256: vowelstr(char *str)
1257: {
1258: switch (*str)
1259: {
1260: case 'a':
1261: case 'e':
1262: case 'i':
1263: case 'o':
1264: case 'u':
1265: return "n";
1266: default:
1267: return "";
1268: }
1269: }
1270:
1271: /*
1272: * wake up a room full (hopefully) of creatures
1273: */
1274:
1275: void
1276: wake_room(struct room *rp)
1277: {
1278: register struct linked_list *item;
1279: register struct thing *tp;
1280:
1281: for (item=mlist; item!=NULL; item=next(item)) {
1282: tp = THINGPTR(item);
1283: if (off(*tp,ISRUN) && on(*tp,ISMEAN) && roomin(&tp->t_pos) == rp)
1284: runto(tp, &hero);
1285: }
1286: }
1287:
1288:
1289: /*
1290: * waste_time:
1291: * Do nothing but let other things happen
1292: */
1293:
1294: void
1295: waste_time(void)
1296: {
1297: if (inwhgt) /* if from wghtchk then done */
1298: return;
1299: do_daemons(BEFORE);
1300: do_fuses(BEFORE);
1301: do_daemons(AFTER);
1302: do_fuses(AFTER);
1303: }
1304: