![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to move.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / early-roguelike / arogue7|
Return to move.c CVS log | Up to [contributed] / early-roguelike / arogue7 |
1.1 rubenllo 1: /*
2: * move.c - Hero movement commands
3: *
4: * Advanced Rogue
5: * Copyright (C) 1984, 1985, 1986 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: /*
16: * Hero movement commands
17: *
18: */
19:
20: #include "curses.h"
21: #include <ctype.h>
22: #include <string.h>
23: #include "rogue.h"
24: #ifdef PC7300
25: #include "menu.h"
26: #endif
27:
28: /*
29: * Used to hold the new hero position
30: */
31:
32: static coord nh;
33:
34: static char Moves[3][3] = {
35: { 'y', 'k', 'u' },
36: { 'h', '.', 'l' },
37: { 'b', 'j', 'n' }
38: };
39:
40: /*
41: * be_trapped:
42: * The guy stepped on a trap.... Make him pay.
43: */
44:
45: char
46: be_trapped(struct thing *th, coord *tc)
47: {
48: register struct trap *tp;
49: register char ch, *mname = "";
50: register bool is_player = (th == &player),
51: can_see;
52: register struct linked_list *mitem = NULL;
53: register struct thing *mp;
54:
55:
56: /* Can the player see the creature? */
57: can_see = (cansee(tc->y, tc->x) && (is_player || !invisible(th)));
58:
59: tp = trap_at(tc->y, tc->x);
60: /*
61: * if he's wearing boots of elvenkind, he won't set off the trap
62: * unless its a magic pool (they're not really traps)
63: */
64: if (is_player &&
65: cur_misc[WEAR_BOOTS] != NULL &&
66: cur_misc[WEAR_BOOTS]->o_which == MM_ELF_BOOTS &&
67: tp->tr_type != POOL)
68: return '\0';
69:
70: /*
71: * if the creature is flying then it won't set off the trap
72: */
73: if (on(*th, ISFLY))
74: return '\0';
75:
76: tp->tr_flags |= ISFOUND;
77:
78: if (!is_player) {
79: mitem = find_mons(th->t_pos.y, th->t_pos.x);
80: mname = monster_name(th);
81: }
82: else {
83: count = running = FALSE;
84: mvwaddch(cw, tp->tr_pos.y, tp->tr_pos.x, tp->tr_type);
85: }
86: switch (ch = tp->tr_type) {
87: case TRAPDOOR:
88: if (is_player) {
89: level++;
90: pstats.s_hpt -= roll(1, 10);
91: if (pstats.s_hpt <= 0) death(D_FALL);
92: new_level(NORMLEV);
93: msg("You fell into a trap!");
94: }
95: else {
96: if (can_see) msg("%s fell into a trap!", prname(mname, TRUE));
97:
98: /*
99: * See if the fall killed the monster
100: * don't let a UNIQUE die since it might have an artifact
101: * that we need
102: */
103: if (off(*th,ISUNIQUE) && (th->t_stats.s_hpt-=roll(1,10)) <= 0){
104: killed(mitem, FALSE, FALSE, FALSE);
105: }
106: else { /* Just move monster to next level */
107: check_residue(th);
108:
109: /* Erase the monster from the old position */
110: if (isalpha(mvwinch(cw, th->t_pos.y, th->t_pos.x)))
111: mvwaddch(cw, th->t_pos.y, th->t_pos.x, th->t_oldch);
112: mvwaddch(mw, th->t_pos.y, th->t_pos.x, ' ');
113:
114: /* let him summon on next lvl */
115: if (on (*th, HASSUMMONED)) {
116: turn_off(*th, HASSUMMONED);
117: turn_on(*th, CANSUMMON);
118: }
119: turn_on(*th,ISELSEWHERE);
120: detach(mlist, mitem);
121: attach(tlist, mitem); /* remember him next level */
122:
123: /* Make sure that no one is still chasing us */
124: for (mitem = mlist; mitem != NULL; mitem = next(mitem)) {
125: mp = THINGPTR(mitem);
126: if (mp->t_dest == &th->t_pos) {
127: mp->t_dest = &hero;
128: mp->t_wasshot = FALSE;
129: turn_off(*mp, ISFLEE); /* Don't run away! */
130: }
131: }
132:
133: /* Make sure we were not chasing a monster here */
134: th->t_dest = &hero;
135: if (on(*th, ISFRIENDLY), turn_off(*th, ISFLEE));
136: }
137: }
138: when BEARTRAP:
139: if (is_stealth(th)) {
140: if (is_player) msg("You pass a bear trap.");
141: else if (can_see) msg("%s passes a bear trap.",
142: prname(mname, TRUE));
143: }
144: else {
145: th->t_no_move += movement(&player) * BEARTIME;
146: th->t_action = A_FREEZE;
147: if (is_player) msg("You are caught in a bear trap.");
148: else if (can_see) msg("%s is caught in a bear trap.",
149: prname(mname, TRUE));
150: }
151: when SLEEPTRAP:
152: if (is_player) {
153: msg("A strange white mist envelops you.");
154: if (!ISWEARING(R_ALERT)) {
155: msg("You fall asleep.");
156: player.t_no_move += movement(&player) * SLEEPTIME;
157: player.t_action = A_FREEZE;
158: }
159: }
160: else {
161: if (can_see)
162: msg("A strange white mist envelops %s.",
163: prname(mname, FALSE));
164: if (on(*th, ISUNDEAD)) {
165: if (can_see)
166: msg("The mist doesn't seem to affect %s.",
167: prname(mname, FALSE));
168: }
169: else {
170: th->t_no_move += movement(th) * SLEEPTIME;
171: th->t_action = A_FREEZE;
172: }
173: }
174: when ARROWTRAP:
175: if (swing(th->t_ctype, th->t_stats.s_lvl-1, th->t_stats.s_arm, 1))
176: {
177: if (is_player) {
178: msg("Oh no! An arrow shot you.");
179: if ((pstats.s_hpt -= roll(1, 6)) <= 0) {
180: msg("The arrow killed you.");
181: death(D_ARROW);
182: }
183: }
184: else {
185: if (can_see)
186: msg("An arrow shot %s.", prname(mname, FALSE));
187: if ((th->t_stats.s_hpt -= roll(1, 6)) <= 0) {
188: if (can_see)
189: msg("The arrow killed %s.", prname(mname, FALSE));
190: killed(mitem, FALSE, FALSE, TRUE);
191: }
192: }
193: }
194: else
195: {
196: register struct linked_list *item;
197: register struct object *arrow;
198:
199: if (is_player) msg("An arrow shoots past you.");
200: else if (can_see)
201: msg("An arrow shoots by %s.", prname(mname, FALSE));
202: item = new_item(sizeof *arrow);
203: arrow = OBJPTR(item);
204: arrow->o_type = WEAPON;
205: arrow->contents = NULL;
206: arrow->o_which = ARROW;
207: arrow->o_hplus = rnd(3) - 1;
208: arrow->o_dplus = rnd(3) - 1;
209: init_weapon(arrow, ARROW);
210: arrow->o_count = 1;
211: arrow->o_pos = *tc;
212: arrow->o_mark[0] = '\0';
213: fall(item, FALSE);
214: }
215: when TELTRAP:
216: if (is_player) teleport();
217: else {
218: register int rm;
219: struct room *old_room; /* old room of monster */
220:
221: /*
222: * Erase the monster from the old position
223: */
224: if (isalpha(mvwinch(cw, th->t_pos.y, th->t_pos.x)))
225: mvwaddch(cw, th->t_pos.y, th->t_pos.x, th->t_oldch);
226: mvwaddch(mw, th->t_pos.y, th->t_pos.x, ' ');
227: /*
228: * check to see if room should go dark
229: */
230: if (on(*th, HASFIRE)) {
231: old_room=roomin(&th->t_pos);
232: if (old_room != NULL) {
233: register struct linked_list *fire_item;
234:
235: for (fire_item = old_room->r_fires; fire_item != NULL;
236: fire_item = next(fire_item)) {
237: if (THINGPTR(fire_item) == th) {
238: detach(old_room->r_fires, fire_item);
239: destroy_item(fire_item);
240:
241: if (old_room->r_fires == NULL) {
242: old_room->r_flags &= ~HASFIRE;
243: if (can_see) light(&hero);
244: }
245: }
246: }
247: }
248: }
249:
250: /* Get a new position */
251: do {
252: rm = rnd_room();
253: rnd_pos(&rooms[rm], &th->t_pos);
254: } until(winat(th->t_pos.y, th->t_pos.x) == FLOOR);
255:
256: /* Put it there */
257: mvwaddch(mw, th->t_pos.y, th->t_pos.x, th->t_type);
258: th->t_oldch = CCHAR( mvwinch(cw, th->t_pos.y, th->t_pos.x) );
259: /*
260: * check to see if room that creature appears in should
261: * light up
262: */
263: if (on(*th, HASFIRE)) {
264: register struct linked_list *fire_item;
265:
266: fire_item = creat_item();
267: ldata(fire_item) = (char *) th;
268: attach(rooms[rm].r_fires, fire_item);
269:
270: rooms[rm].r_flags |= HASFIRE;
271: if(cansee(th->t_pos.y, th->t_pos.x) &&
272: next(rooms[rm].r_fires) == NULL)
273: light(&hero);
274: }
275: if (can_see)
276: msg("%s seems to have disappeared!", prname(mname, TRUE));
277: }
278: when DARTTRAP:
279: if (swing(th->t_ctype, th->t_stats.s_lvl+1, th->t_stats.s_arm, 1)) {
280: if (is_player) {
281: msg("A small dart just hit you in the shoulder.");
282: if ((pstats.s_hpt -= roll(1, 4)) <= 0) {
283: msg("The dart killed you.");
284: death(D_DART);
285: }
286:
287: /* Now the poison */
288: if (!save(VS_POISON, &player, 0)) {
289: /* 75% chance it will do point damage - else strength */
290: if (rnd(100) < 75) {
291: pstats.s_hpt /= 2;
292: if (pstats.s_hpt == 0) death(D_POISON);
293: }
294: else if (!ISWEARING(R_SUSABILITY))
295: chg_str(-1);
296: }
297: }
298: else {
299: if (can_see)
300: msg("A small dart just hit %s in the shoulder.",
301: prname(mname, FALSE));
302: if ((th->t_stats.s_hpt -= roll(1,4)) <= 0) {
303: if (can_see)
304: msg("The dart killed %s.", prname(mname, FALSE));
305: killed(mitem, FALSE, FALSE, TRUE);
306: }
307: if (!save(VS_POISON, th, 0)) {
308: th->t_stats.s_hpt /= 2;
309: if (th->t_stats.s_hpt <= 0) {
310: if (can_see)
311: msg("The dart killed %s.", prname(mname,FALSE));
312: killed(mitem, FALSE, FALSE, TRUE);
313: }
314: }
315: }
316: }
317: else {
318: if (is_player)
319: msg("A small dart whizzes by your ear and vanishes.");
320: else if (can_see)
321: msg("A small dart whizzes by %s's ear and vanishes.",
322: prname(mname, FALSE));
323: }
324: when POOL: {
325: register int i;
326:
327: i = rnd(100);
328: if (is_player) {
329: if ((tp->tr_flags & ISGONE)) {
330: if (i < 30) {
331: teleport(); /* teleport away */
332: pool_teleport = TRUE;
333: }
334: else if((i < 45) && level > 2) {
335: level -= rnd(2) + 1;
336: cur_max = level;
337: new_level(NORMLEV);
338: pool_teleport = TRUE;
339: msg("You here a faint groan from below.");
340: }
341: else if(i < 70) {
342: level += rnd(4) + 1;
343: new_level(NORMLEV);
344: pool_teleport = TRUE;
345: msg("You find yourself in strange surroundings.");
346: }
347: else if(i > 95) {
348: msg("Oh no!!! You drown in the pool!!! --More--");
349: wait_for(' ');
350: death(D_DROWN);
351: }
352: }
353: }
354: else {
355: if (i < 60) {
356: if (can_see) {
357: /* Drowns */
358: if (i < 30)
359: msg("%s drowned in the pool!", prname(mname, TRUE));
360:
361: /* Teleported to another level */
362: else msg("%s disappeared!", prname(mname, TRUE));
363: }
364: killed(mitem, FALSE, FALSE, TRUE);
365: }
366: }
367: }
368: when MAZETRAP:
369: if (is_player) {
370: pstats.s_hpt -= roll(1, 10);
371: level++;
372: msg("You fell through a trap door!");
373: if (pstats.s_hpt <= 0) death(D_FALL);
374: new_level(MAZELEV);
375: msg("You are surrounded by twisty passages!");
376: }
377: else {
378: if (can_see) msg("%s fell into a trap!", prname(mname, TRUE));
379:
380: if (on(*th, ISUNIQUE)) {
381: check_residue(th);
382:
383: /* Erase the monster from the old position */
384: if (isalpha(mvwinch(cw, th->t_pos.y, th->t_pos.x)))
385: mvwaddch(cw, th->t_pos.y, th->t_pos.x, th->t_oldch);
386: mvwaddch(mw, th->t_pos.y, th->t_pos.x, ' ');
387:
388: /* let him summon on next lvl */
389: if (on (*th, HASSUMMONED)) {
390: turn_off(*th, HASSUMMONED);
391: turn_on(*th, CANSUMMON);
392: }
393: turn_on(*th,ISELSEWHERE);
394: detach(mlist, mitem);
395: attach(tlist, mitem); /* remember him next level */
396:
397: /* Make sure that no one is still chasing us */
398: for (mitem = mlist; mitem != NULL; mitem = next(mitem)) {
399: mp = THINGPTR(mitem);
400: if (mp->t_dest == &th->t_pos) {
401: mp->t_dest = &hero;
402: mp->t_wasshot = FALSE;
403: turn_off(*mp, ISFLEE); /* Don't run away! */
404: }
405: }
406:
407: /* Make sure we were not chasing a monster here */
408: th->t_dest = &hero;
409: if (on(*th, ISFRIENDLY), turn_off(*th, ISFLEE));
410: }
411: else
412: killed(mitem, FALSE, FALSE, FALSE);
413: }
414: }
415:
416: /* Move the cursor back onto the hero */
417: wmove(cw, hero.y, hero.x);
418:
419: md_flushinp();
420: return(ch);
421: }
422:
423: /*
424: * blue_light:
425: * magically light up a room (or level or make it dark)
426: */
427:
428: bool
429: blue_light(bool blessed, bool cursed)
430: {
431: register struct room *rp;
432: bool ret_val=FALSE; /* Whether or not affect is known */
433:
434: rp = roomin(&hero); /* What room is hero in? */
435:
436: /* Darken the room if the magic is cursed */
437: if (cursed) {
438: if ((rp == NULL) || !lit_room(rp)) msg(nothing);
439: else {
440: rp->r_flags |= ISDARK;
441: if (!lit_room(rp) && (levtype != OUTSIDE || !daytime))
442: msg("The %s suddenly goes dark.",
443: levtype == OUTSIDE ? "area" : "room");
444: else msg(nothing);
445: ret_val = TRUE;
446: }
447: }
448: else {
449: ret_val = TRUE;
450: if (rp && !lit_room(rp) &&
451: (levtype != OUTSIDE || !daytime)) {
452: addmsg("The %s is lit", levtype == OUTSIDE ? "area" : "room");
453: if (!terse)
454: addmsg(" by a %s blue light.",
455: blessed ? "bright" : "shimmering");
456: endmsg();
457: }
458: else if (winat(hero.y, hero.x) == PASSAGE)
459: msg("The corridor glows %sand then fades",
460: blessed ? "brightly " : "");
461: else {
462: ret_val = FALSE;
463: msg(nothing);
464: }
465: if (blessed) {
466: register int i; /* Index through rooms */
467:
468: for (i=0; i<MAXROOMS; i++)
469: rooms[i].r_flags &= ~ISDARK;
470: }
471: else if (rp) rp->r_flags &= ~ISDARK;
472: }
473:
474: /*
475: * Light the room and put the player back up
476: */
477: light(&hero);
478: mvwaddch(cw, hero.y, hero.x, PLAYER);
479: return(ret_val);
480: }
481:
482: /*
483: * corr_move:
484: * Check to see that a move is legal. If so, return correct character.
485: * If not, if player came from a legal place, then try to turn him.
486: */
487:
488: void
489: corr_move(int dy, int dx)
490: {
491: int legal=0; /* Number of legal alternatives */
492: register int y, x, /* Indexes though possible positions */
493: locy, locx; /* Hold delta of chosen location */
494:
495: /* New position */
496: nh.y = hero.y + dy;
497: nh.x = hero.x + dx;
498:
499: /* If it is a legal move, just return */
500: if (nh.x >= 0 && nh.x < cols && nh.y > 0 && nh.y < lines - 2) {
501:
502: switch (winat(nh.y, nh.x)) {
503: case WALL:
504: case '|':
505: case '-':
506: break;
507: default:
508: if (diag_ok(&hero, &nh, &player))
509: return;
510: }
511: }
512:
513: /* Check legal places surrounding the player -- ignore previous position */
514: for (y = hero.y - 1; y <= hero.y + 1; y++) {
515: if (y < 1 || y > lines - 3)
516: continue;
517: for (x = hero.x - 1; x <= hero.x + 1; x++) {
518: /* Ignore borders of the screen */
519: if (x < 0 || x > cols - 1)
520: continue;
521:
522: /*
523: * Ignore where we came from, where we are, and where we couldn't go
524: */
525: if ((x == hero.x - dx && y == hero.y - dy) ||
526: (x == hero.x + dx && y == hero.y + dy) ||
527: (x == hero.x && y == hero.y))
528: continue;
529:
530: switch (winat(y, x)) {
531: case WALL:
532: case '|':
533: case '-':
534: break;
535: default:
536: nh.y = y;
537: nh.x = x;
538: if (diag_ok(&hero, &nh, &player)) {
539: legal++;
540: locy = y - (hero.y - 1);
541: locx = x - (hero.x - 1);
542: }
543: }
544: }
545: }
546:
547: /* If we have 2 or more legal moves, make no change */
548: if (legal != 1) {
549: return;
550: }
551:
552: runch = Moves[locy][locx];
553:
554: /*
555: * For mazes, pretend like it is the beginning of a new run at each turn
556: * in order to get the lighting correct.
557: */
558: if (levtype == MAZELEV) firstmove = TRUE;
559: return;
560: }
561:
562: /*
563: * dip_it:
564: * Dip an object into a magic pool
565: */
566: void
567: dip_it(void)
568: {
569: reg struct linked_list *what;
570: reg struct object *ob;
571: reg struct trap *tp;
572: reg int wh, i;
573:
574: tp = trap_at(hero.y,hero.x);
575: if (tp == NULL || tp->tr_type != POOL) {
576: msg("I see no shimmering pool here");
577: return;
578: }
579: if (tp->tr_flags & ISGONE) {
580: msg("This shimmering pool appears to have been used once already.");
581: return;
582: }
583:
584: /* It takes 3 movement periods to dip something */
585: if (player.t_action != C_DIP) {
586: if ((what = get_item(pack, "dip", ALL, FALSE, FALSE)) == NULL) {
587: msg("");
588: after = FALSE;
589: return;
590: }
591:
592: ob = OBJPTR(what);
593: if (ob == cur_armor ||
594: ob == cur_misc[WEAR_BOOTS] || ob == cur_misc[WEAR_JEWEL] ||
595: ob == cur_misc[WEAR_GAUNTLET] ||
596: ob == cur_misc[WEAR_CLOAK] ||
597: ob == cur_misc[WEAR_BRACERS] ||
598: ob == cur_misc[WEAR_NECKLACE]||
599: ob == cur_ring[LEFT_1] || ob == cur_ring[LEFT_2] ||
600: ob == cur_ring[LEFT_3] || ob == cur_ring[LEFT_4] ||
601: ob == cur_ring[RIGHT_1] || ob == cur_ring[RIGHT_2] ||
602: ob == cur_ring[RIGHT_3] || ob == cur_ring[RIGHT_4]) {
603: mpos = 0;
604: msg("You'll have to take it off first.");
605: return;
606: }
607:
608: player.t_using = what; /* Remember what it is */
609: player.t_action = C_DIP; /* We are dipping */
610: player.t_no_move = 3 * movement(&player);
611: return;
612: }
613:
614: /* We have waited our time, let's dip it */
615: what = player.t_using;
616: player.t_using = NULL;
617: player.t_action = A_NIL;
618:
619: ob = OBJPTR(what);
620:
621: tp->tr_flags |= ISGONE;
622: if (ob != NULL) {
623: wh = ob->o_which;
624: ob->o_flags |= ISKNOW;
625: i = rnd(100);
626: switch(ob->o_type) {
627: case WEAPON:
628: if(i < 50) { /* enchant weapon here */
629: if ((ob->o_flags & ISCURSED) == 0) {
630: ob->o_hplus += 1;
631: ob->o_dplus += 1;
632: }
633: else { /* weapon was prev cursed here */
634: ob->o_hplus = rnd(2);
635: ob->o_dplus = rnd(2);
636: }
637: ob->o_flags &= ~ISCURSED;
638: msg("The %s glows blue for a moment.",weaps[wh].w_name);
639: }
640: else if(i < 70) { /* curse weapon here */
641: if ((ob->o_flags & ISCURSED) == 0) {
642: ob->o_hplus = -(rnd(2)+1);
643: ob->o_dplus = -(rnd(2)+1);
644: }
645: else { /* if already cursed */
646: ob->o_hplus--;
647: ob->o_dplus--;
648: }
649: ob->o_flags |= ISCURSED;
650: msg("The %s glows red for a moment.",weaps[wh].w_name);
651: }
652: else
653: msg(nothing);
654: when ARMOR:
655: if (i < 50) { /* enchant armor */
656: if((ob->o_flags & ISCURSED) == 0)
657: ob->o_ac -= rnd(2) + 1;
658: else
659: ob->o_ac = -rnd(3)+ armors[wh].a_class;
660: ob->o_flags &= ~ISCURSED;
661: msg("The %s glows blue for a moment",armors[wh].a_name);
662: }
663: else if(i < 75){ /* curse armor */
664: if ((ob->o_flags & ISCURSED) == 0)
665: ob->o_ac = rnd(3)+ armors[wh].a_class;
666: else
667: ob->o_ac += rnd(2) + 1;
668: ob->o_flags |= ISCURSED;
669: msg("The %s glows red for a moment.",armors[wh].a_name);
670: }
671: else
672: msg(nothing);
673: when STICK: {
674: int j;
675: j = rnd(8) + 1;
676: if(i < 50) { /* add charges */
677: ob->o_charges += j;
678: ws_know[wh] = TRUE;
679: if (ob->o_flags & ISCURSED)
680: ob->o_flags &= ~ISCURSED;
681: msg("The %s %s glows blue for a moment.",
682: ws_made[wh],ws_type[wh]);
683: }
684: else if(i < 65) { /* remove charges */
685: if ((ob->o_charges -= i) < 0)
686: ob->o_charges = 0;
687: ws_know[wh] = TRUE;
688: if (ob->o_flags & ISBLESSED)
689: ob->o_flags &= ~ISBLESSED;
690: else
691: ob->o_flags |= ISCURSED;
692: msg("The %s %s glows red for a moment.",
693: ws_made[wh],ws_type[wh]);
694: }
695: else
696: msg(nothing);
697: }
698: when SCROLL:
699: s_know[wh] = TRUE;
700: msg("The '%s' scroll unfurls.",s_names[wh]);
701: when POTION:
702: p_know[wh] = TRUE;
703: msg("The %s potion bubbles for a moment.",p_colors[wh]);
704: when RING:
705: if(i < 50) { /* enchant ring */
706: if ((ob->o_flags & ISCURSED) == 0)
707: ob->o_ac += rnd(2) + 1;
708: else
709: ob->o_ac = rnd(2) + 1;
710: ob->o_flags &= ~ISCURSED;
711: }
712: else if(i < 80) { /* curse ring */
713: if ((ob->o_flags & ISCURSED) == 0)
714: ob->o_ac = -(rnd(2) + 1);
715: else
716: ob->o_ac -= (rnd(2) + 1);
717: ob->o_flags |= ISCURSED;
718: }
719: r_know[wh] = TRUE;
720: msg("The %s ring vibrates for a moment.",r_stones[wh]);
721: when MM:
722: m_know[wh] = TRUE;
723: switch (ob->o_which) {
724: case MM_BRACERS:
725: case MM_PROTECT:
726: if(i < 50) { /* enchant item */
727: if ((ob->o_flags & ISCURSED) == 0)
728: ob->o_ac += rnd(2) + 1;
729: else
730: ob->o_ac = rnd(2) + 1;
731: ob->o_flags &= ~ISCURSED;
732: }
733: else if(i < 80) { /* curse item */
734: if ((ob->o_flags & ISCURSED) == 0)
735: ob->o_ac = -(rnd(2) + 1);
736: else
737: ob->o_ac -= (rnd(2) + 1);
738: ob->o_flags |= ISCURSED;
739: }
740: msg("The item vibrates for a moment.");
741: when MM_CHOKE:
742: case MM_DISAPPEAR:
743: ob->o_ac = 0;
744: msg ("The dust dissolves in the pool!");
745: }
746: otherwise:
747: msg("The pool bubbles for a moment.");
748: }
749: updpack(FALSE, &player);
750: }
751: else
752: msg(nothing);
753: }
754:
755: /*
756: * do_move:
757: * Check to see that a move is legal. If it is handle the
758: * consequences (fighting, picking up, etc.)
759: */
760:
761: void
762: do_move(int dy, int dx)
763: {
764: register struct room *rp, *orp;
765: register char ch;
766: struct linked_list *item;
767: register struct thing *tp = NULL;
768: coord old_hero;
769: register int wasfirstmove, moved, num_hits;
770: bool changed=FALSE; /* Did we switch places with a friendly monster? */
771:
772: wasfirstmove = firstmove;
773: firstmove = FALSE;
774: curprice = -1; /* if in trading post, we've moved off obj */
775:
776: /*
777: * Do a confused move (maybe)
778: */
779: if (player.t_action == A_NIL &&
780: ((on(player, ISHUH) && rnd(100) < 80) ||
781: (on(player, ISDANCE) && rnd(100) < 80) ||
782: (ISWEARING(R_DELUSION) && rnd(100) < 25)))
783: /* Get a random move */
784: nh = *rndmove(&player);
785: else {
786: nh.y = hero.y + dy;
787: nh.x = hero.x + dx;
788: }
789:
790: /*
791: * Check if he tried to move off the screen or make an illegal
792: * diagonal move, and stop him if he did.
793: */
794: if (nh.x < 0 || nh.x > cols-1 || nh.y < 1 || nh.y >= lines - 2
795: || !diag_ok(&hero, &nh, &player))
796: {
797: after = running = FALSE;
798: player.t_action = A_NIL;
799: return;
800: }
801: if (running && ce(hero, nh))
802: after = running = FALSE;
803: ch = CCHAR( winat(nh.y, nh.x) );
804:
805: /* Take care of hero trying to move close to something frightening */
806: if (on(player, ISFLEE)) {
807: if (rnd(100) < 10) {
808: turn_off(player, ISFLEE);
809: msg("You regain your composure.");
810: }
811: else if (DISTANCE(nh.y, nh.x, player.t_dest->y, player.t_dest->x) <
812: DISTANCE(hero.y, hero.x, player.t_dest->y, player.t_dest->x)) {
813: running = FALSE;
814: msg("You are too terrified to move that way");
815: player.t_action = A_NIL;
816: player.t_no_move = movement(&player);
817: return;
818: }
819: }
820:
821: /* If we want to move to a monster, see what it is */
822: if (isalpha(ch)) {
823: item = find_mons(nh.y, nh.x);
824: if (item == NULL) {
825: debug("Cannot find monster in move.");
826: player.t_action = A_NIL;
827: return;
828: }
829: tp = THINGPTR(item);
830: }
831:
832: /*
833: * Take care of hero being held. If the player is being held, he
834: * can't move unless he is either attacking a non-friendly monster
835: * or attacking a friendly monster that can't move.
836: */
837: if (on(player, ISHELD) &&
838: (!isalpha(ch) || (on(*tp, ISFRIENDLY) && off(*tp, ISHELD)))) {
839: msg("You are being held.");
840: player.t_action = A_NIL;
841: return;
842: }
843:
844: /* See if we have to wait for our movement rate */
845: if (player.t_action == A_NIL) {
846: after = FALSE;
847: firstmove = wasfirstmove; /* Remember if this is first move */
848: player.t_no_move = movement(&player);
849: if (player.t_ctype == C_MONK)
850: player.t_no_move -= pstats.s_lvl/6;
851: if (on(player, ISFLY))
852: player.t_no_move /= 2; /* If flying, speed him up */
853:
854: if (player.t_no_move < 1) player.t_no_move = 1;
855:
856: /* Remember our action */
857: player.t_action = Moves[dy+1][dx+1];
858: return;
859: }
860:
861: /* Now let's forget the old move and just do it */
862: player.t_action = A_NIL;
863:
864: /* If we're moving onto a friendly monster, let's change places. */
865: if (isalpha(ch) && on(*tp, ISFRIENDLY) && off(*tp, ISHELD)) {
866: coord tpos, /* Where monster may have been going */
867: current; /* Current hero position */
868: int action; /* The monster's action */
869:
870: current = hero;
871: tpos = tp->t_newpos;
872: action = tp->t_action;
873:
874: /* Disrupt whatever our friend was doing */
875: tp->t_action = A_NIL;
876:
877: /* Tentatively move us to where he is */
878: hero = tp->t_pos;
879:
880: /* See if we can move him to where we were */
881: tp->t_newpos = current;
882: do_chase(tp);
883:
884: /* Did we succeed? */
885: if (ce(tp->t_pos, current)) {
886: /* Reset our idea of what ch is */
887: ch = CCHAR( winat(nh.y, nh.x) );
888:
889: /* Let it be known that we made the switch */
890: changed = TRUE;
891: old_hero = current;
892:
893: /* Make the monster think it didn't move */
894: tp->t_oldpos = current;
895: tp->t_doorgoal = NULL;
896:
897: /* Let the player know something funny happened. */
898: msg("What a sidestep!");
899: }
900: else {
901: /* Restore things -- we couldn't move */
902: hero = current;
903: tp->t_newpos = tpos;
904: tp->t_action = action;
905: }
906: }
907:
908: /* assume he's not in a wall */
909: if (!isalpha(ch)) turn_off(player, ISINWALL);
910:
911: switch (ch) {
912: case '|':
913: case '-':
914: if (levtype == OUTSIDE) {
915: hero = nh;
916: new_level(OUTSIDE);
917: return;
918: }
919: case WALL:
920: case SECRETDOOR:
921: if (off(player, CANINWALL) || running) {
922: after = running = FALSE;
923:
924: /* Light if finishing run */
925: if (levtype == MAZELEV && lit_room(&rooms[0]))
926: look(FALSE, TRUE);
927:
928: after = running = FALSE;
929:
930: return;
931: }
932: turn_on(player, ISINWALL);
933: break;
934: case POOL:
935: if (levtype == OUTSIDE) {
936: lake_check(&nh);
937: running = FALSE;
938: break;
939: }
940: case MAZETRAP:
941: if (levtype == OUTSIDE) {
942: running = FALSE;
943: break;
944: }
945: case TRAPDOOR:
946: case TELTRAP:
947: case BEARTRAP:
948: case SLEEPTRAP:
949: case ARROWTRAP:
950: case DARTTRAP:
951: ch = be_trapped(&player, &nh);
952: if (ch == TRAPDOOR || ch == TELTRAP ||
953: pool_teleport || ch == MAZETRAP) {
954: pool_teleport = FALSE;
955: return;
956: }
957: break;
958: case GOLD:
959: case POTION:
960: case SCROLL:
961: case FOOD:
962: case WEAPON:
963: case ARMOR:
964: case RING:
965: case MM:
966: case RELIC:
967: case STICK:
968: running = FALSE;
969: take = ch;
970: break;
971: case DOOR:
972: case STAIRS:
973: case POST:
974: running = FALSE;
975: break;
976: default:
977: break;
978: }
979:
980: if (isalpha(ch)) { /* if its a monster then fight it */
981: /*
982: * If we were running down a corridor and didn't start right
983: * next to the critter, don't do anything.
984: */
985: if (running && wasfirstmove == FALSE && roomin(&hero) == NULL) {
986: struct linked_list *item;
987:
988: item = find_mons(nh.y, nh.x);
989: if (item != NULL && !invisible(THINGPTR(item))) {
990: after = running = FALSE;
991: return;
992: }
993: }
994:
995: /* We have to add time because we're attacking */
996: player.t_no_move = FIGHTBASE;
997: player.t_no_move += weap_move(&player, cur_weapon);
998: if (on(player, ISHASTE))
999: player.t_no_move /= 2;
1000: else if (on(player, ISSLOW))
1001: player.t_no_move *= 2;
1002:
1003: /* We may attack faster if we're high enough level
1004: * and the right class
1005: */
1006: switch(player.t_ctype) {
1007: case C_FIGHTER: num_hits = player.t_stats.s_lvl/9 + 1;
1008: when C_PALADIN: num_hits = player.t_stats.s_lvl/12 + 1;
1009: when C_RANGER: num_hits = player.t_stats.s_lvl/13 + 1;
1010: when C_MONK: if(cur_weapon) num_hits= 1;
1011: else num_hits= player.t_stats.s_lvl/5 + 1;
1012: otherwise: num_hits = 1;
1013: }
1014:
1015: /*
1016: * The player has already moved the initial movement period.
1017: * Let's add that in, do our division, and then subtract it
1018: * out so that the total time is divided, not just the
1019: * additional attack time.
1020: */
1021: moved = movement(&player),
1022: player.t_no_move += moved;
1023: player.t_no_move /= num_hits;
1024: player.t_no_move -= moved;
1025: running = FALSE;
1026:
1027: /* Mark that we are attacking and save the attack coordinate */
1028: player.t_action = A_ATTACK;
1029: player.t_newpos = nh;
1030: runch = Moves[dy+1][dx+1]; /* Remember the direction */
1031:
1032: if (player.t_no_move <= 0) after = FALSE;
1033: return;
1034: }
1035:
1036: /*
1037: * if not fighting then move the hero
1038: */
1039: if (changed == FALSE) {
1040: old_hero = hero; /* Save hero's old position */
1041: hero = nh; /* Move the hero */
1042: }
1043: rp = roomin(&hero);
1044: orp = roomin(&old_hero);
1045:
1046: /* Unlight any possible cross-corridor */
1047: if (levtype == MAZELEV) {
1048: register bool call_light = FALSE;
1049: register char wall_check;
1050:
1051: if (wasfirstmove && lit_room(&rooms[0])) {
1052: /* Are we moving out of a corridor? */
1053: switch (runch) {
1054: case 'h':
1055: case 'l':
1056: if (old_hero.y + 1 < lines - 2) {
1057: wall_check = CCHAR( winat(old_hero.y + 1, old_hero.x) );
1058: if (!isrock(wall_check)) call_light = TRUE;
1059: }
1060: if (old_hero.y - 1 > 0) {
1061: wall_check = CCHAR( winat(old_hero.y - 1, old_hero.x) );
1062: if (!isrock(wall_check)) call_light = TRUE;
1063: }
1064: break;
1065: case 'j':
1066: case 'k':
1067: if (old_hero.x + 1 < cols) {
1068: wall_check = CCHAR( winat(old_hero.y, old_hero.x + 1) );
1069: if (!isrock(wall_check)) call_light = TRUE;
1070: }
1071: if (old_hero.x - 1 >= 0) {
1072: wall_check = CCHAR( winat(old_hero.y, old_hero.x - 1) );
1073: if (!isrock(wall_check)) call_light = TRUE;
1074: }
1075: break;
1076: default:
1077: call_light = TRUE;
1078: }
1079: player.t_oldpos = old_hero;
1080: if (call_light) light(&old_hero);
1081: }
1082: }
1083:
1084: else if (orp != NULL && rp == NULL) { /* Leaving a room -- darken it */
1085: orp->r_flags |= FORCEDARK; /* Fake darkness */
1086: light(&old_hero);
1087: orp->r_flags &= ~FORCEDARK; /* Restore light state */
1088: }
1089: else if (rp != NULL && orp == NULL){/* Entering a room */
1090: light(&hero);
1091: if (rp->r_flags & ISTREAS)
1092: wake_room(rp);
1093: }
1094: ch = CCHAR( winat(old_hero.y, old_hero.x) );
1095: wmove(cw, unc(old_hero));
1096: waddch(cw, ch);
1097: wmove(cw, unc(hero));
1098: waddch(cw, PLAYER);
1099: }
1100:
1101: /*
1102: * do_run:
1103: * Start the hero running
1104: */
1105:
1106: void
1107: do_run(char ch)
1108: {
1109: firstmove = TRUE;
1110: running = TRUE;
1111: after = FALSE;
1112: runch = ch;
1113: }
1114:
1115: /*
1116: * getdelta:
1117: * Takes a movement character (eg. h, j, k, l) and returns the
1118: * y and x delta corresponding to it in the remaining arguments.
1119: * Returns TRUE if it could find it, FALSE otherwise.
1120: */
1121: bool
1122: getdelta(char match, int *dy, int *dx)
1123: {
1124: int y, x;
1125:
1126: for (y = 0; y < 3; y++)
1127: for (x = 0; x < 3; x++)
1128: if (Moves[y][x] == match) {
1129: *dy = y - 1;
1130: *dx = x - 1;
1131: return(TRUE);
1132: }
1133:
1134: return(FALSE);
1135: }
1136:
1137: /*
1138: * isatrap:
1139: * Returns TRUE if this character is some kind of trap
1140: */
1141: bool
1142: isatrap(char ch)
1143: {
1144: switch(ch) {
1145: case DARTTRAP:
1146: case TELTRAP:
1147: case TRAPDOOR:
1148: case ARROWTRAP:
1149: case SLEEPTRAP:
1150: case BEARTRAP: return(TRUE);
1151: case MAZETRAP:
1152: case POOL: return(levtype != OUTSIDE);
1153: default: return(FALSE);
1154: }
1155: }
1156:
1157: /*
1158: * Called to illuminate a room.
1159: * If it is dark, remove anything that might move.
1160: */
1161:
1162: void
1163: light(coord *cp)
1164: {
1165: register struct room *rp;
1166: register int j, k, x, y;
1167: register char ch, rch, sch;
1168: register struct linked_list *item;
1169: int jlow, jhigh, klow, khigh; /* Boundaries of lit area */
1170:
1171: if ((rp = roomin(cp)) != NULL) {
1172: /*
1173: * is he wearing ring of illumination?
1174: */
1175: if (&hero == cp && ISWEARING(R_LIGHT)) /* Must be hero's room */
1176: rp->r_flags &= ~ISDARK;
1177:
1178: /* If we are in a maze, don't look at the whole room (level) */
1179: if (levtype == MAZELEV) {
1180: int see_radius;
1181:
1182: see_radius = 1;
1183:
1184: /* If we are looking at the hero in a rock, broaden our sights */
1185: if (&hero == cp || &player.t_oldpos == cp) {
1186: ch = CCHAR( winat(hero.y, hero.x) );
1187: if (isrock(ch)) see_radius = 2;
1188: ch = CCHAR( winat(player.t_oldpos.y, player.t_oldpos.x) );
1189: if (isrock(ch)) see_radius = 2;
1190: }
1191:
1192: jlow = max(0, cp->y - see_radius - rp->r_pos.y);
1193: jhigh = min(rp->r_max.y, cp->y + see_radius + 1 - rp->r_pos.y);
1194: klow = max(0, cp->x - see_radius - rp->r_pos.x);
1195: khigh = min(rp->r_max.x, cp->x + see_radius + 1 - rp->r_pos.x);
1196: }
1197: else {
1198: jlow = klow = 0;
1199: jhigh = rp->r_max.y;
1200: khigh = rp->r_max.x;
1201: }
1202: for (j = 0; j < rp->r_max.y; j++)
1203: {
1204: for (k = 0; k < rp->r_max.x; k++)
1205: {
1206: bool see_here, see_before;
1207:
1208: /* Is this in the give area -- needed for maze */
1209: if ((j < jlow || j >= jhigh) && (k < klow || k >= khigh))
1210: continue;
1211:
1212: y = rp->r_pos.y + j;
1213: x = rp->r_pos.x + k;
1214:
1215: /*
1216: * If we are in a maze do not look at this area unless
1217: * we can see it from where we are or where we last were
1218: * (for erasing purposes).
1219: */
1220: if (levtype == MAZELEV) {
1221: /* If we can't see it from here, could we see it before? */
1222: if ((see_here = maze_view(y, x)) == FALSE) {
1223: coord savhero;
1224:
1225: /* Could we see it from where we were? */
1226: savhero = hero;
1227: hero = player.t_oldpos;
1228: see_before = maze_view(y, x);
1229: hero = savhero;
1230:
1231: if (!see_before) continue;
1232: }
1233: }
1234:
1235: ch = show(y, x);
1236: wmove(cw, y, x);
1237: /*
1238: * Figure out how to display a secret door
1239: */
1240: if (ch == SECRETDOOR) {
1241: if (j == 0 || j == rp->r_max.y - 1)
1242: ch = '-';
1243: else
1244: ch = '|';
1245: }
1246: /* For monsters, if they were previously not seen and
1247: * now can be seen, or vice-versa, make sure that will
1248: * happen. This is for dark rooms as opposed to invisibility.
1249: *
1250: * Call winat() in the test because ch will not reveal
1251: * invisible monsters.
1252: */
1253: if (isalpha(winat(y, x))) {
1254: struct thing *tp; /* The monster */
1255:
1256: item = wake_monster(y, x);
1257: tp = THINGPTR(item);
1258:
1259: /* Previously not seen -- now can see it */
1260: if (tp->t_oldch == ' ' && cansee(tp->t_pos.y, tp->t_pos.x))
1261: tp->t_oldch = CCHAR( mvinch(y, x) );
1262:
1263: /* Previously seen -- now can't see it */
1264: else if (!cansee(tp->t_pos.y, tp->t_pos.x) &&
1265: roomin(&tp->t_pos) != NULL)
1266: switch (tp->t_oldch) {
1267: /*
1268: * Only blank it out if it is in a room and not
1269: * the border (or other wall) of the room.
1270: */
1271: case DOOR:
1272: case SECRETDOOR:
1273: case '-':
1274: case '|':
1275: break;
1276:
1277: otherwise:
1278: tp->t_oldch = ' ';
1279: }
1280: }
1281:
1282: /*
1283: * If the room is a dark room, we might want to remove
1284: * monsters and the like from it (since they might
1285: * move).
1286: * A dark room.
1287: */
1288: if ((!lit_room(rp) && (levtype != OUTSIDE)) ||
1289: (levtype == OUTSIDE && !daytime) ||
1290: on(player, ISBLIND) ||
1291: (rp->r_flags & FORCEDARK) ||
1292: (levtype == MAZELEV && !see_here && see_before)) {
1293: sch = CCHAR( mvwinch(cw, y, x) ); /* What's seen */
1294: rch = CCHAR( mvinch(y, x) ); /* What's really there */
1295: switch (rch) {
1296: case DOOR:
1297: case SECRETDOOR:
1298: case STAIRS:
1299: case TRAPDOOR:
1300: case TELTRAP:
1301: case BEARTRAP:
1302: case SLEEPTRAP:
1303: case ARROWTRAP:
1304: case DARTTRAP:
1305: case MAZETRAP:
1306: case POOL:
1307: case POST:
1308: case '|':
1309: case '-':
1310: case WALL:
1311: if (isalpha(sch)) ch = rch;
1312: else if (sch != FLOOR) ch = sch;
1313: else ch = ' '; /* Hide undiscoverd things */
1314: when FLOOR:
1315: ch = ' ';
1316: otherwise:
1317: ch = ' ';
1318: }
1319: /* Take care of our magic bookkeeping. */
1320: switch (sch) {
1321: case MAGIC:
1322: case BMAGIC:
1323: case CMAGIC:
1324: ch = sch;
1325: }
1326: }
1327: mvwaddch(cw, y, x, ch);
1328: }
1329: }
1330: }
1331: }
1332:
1333: /*
1334: * lit_room:
1335: * Called to see if the specified room is lit up or not.
1336: */
1337:
1338: bool
1339: lit_room(struct room *rp)
1340: {
1341: register struct linked_list *fire_item;
1342: register struct thing *fire_creature;
1343:
1344: if (!(rp->r_flags & ISDARK)) return(TRUE); /* A definitely lit room */
1345:
1346: /* Is it lit by fire light? */
1347: if (rp->r_flags & HASFIRE) {
1348: switch ((int)levtype) {
1349: case MAZELEV:
1350: /* See if a fire creature is in line of sight */
1351: for (fire_item = rp->r_fires; fire_item != NULL;
1352: fire_item = next(fire_item)) {
1353: fire_creature = THINGPTR(fire_item);
1354: if (maze_view(fire_creature->t_pos.y,
1355: fire_creature->t_pos.x)) return(TRUE);
1356: }
1357:
1358: /* Couldn't find any in line-of-sight */
1359: return(FALSE);
1360:
1361: /* We should probably do something special for the outside */
1362: otherwise:
1363: return TRUE;
1364: }
1365: }
1366: return(FALSE);
1367: }
1368:
1369: /*
1370: * movement:
1371: * Given a pointer to a player/monster structure, calculate the
1372: * movement rate for that character.
1373: */
1374:
1375: short
1376: movement(struct thing *tp)
1377: {
1378: register int result;
1379: register int carry; /* Percentage carried */
1380:
1381: result = 0;
1382:
1383: /* Adjust for armor (player only) */
1384: if (tp == &player && cur_armor) {
1385: int diff; /* Now armor class differs from normal one of same type */
1386:
1387: /* Blessed armor adds less */
1388: diff = cur_armor->o_ac - armors[cur_armor->o_which].a_class;
1389: switch (cur_armor->o_which) {
1390: case LEATHER:
1391: case RING_MAIL:
1392: case STUDDED_LEATHER:
1393: case SCALE_MAIL:
1394: case PADDED_ARMOR:
1395: diff += 1;
1396: when CHAIN_MAIL:
1397: case SPLINT_MAIL:
1398: case BANDED_MAIL:
1399: case PLATE_MAIL:
1400: diff += 2;
1401: when PLATE_ARMOR:
1402: diff += 3;
1403: otherwise:
1404: debug("forgot an armor in movement()");
1405: }
1406: if (diff < 0) diff = 0;
1407: result += diff;
1408:
1409: }
1410:
1411: /* Adjust for the pack */
1412: carry = 100 * tp->t_stats.s_pack / tp->t_stats.s_carry;
1413: if (carry > 75) result++;
1414:
1415: /* Get a bonus for dexterity */
1416: result -= dext_plus(tp == &player ? dex_compute() : tp->t_stats.s_dext);
1417:
1418: /* only allow adjust for the minus's */
1419: if (result < 0) result = 0;
1420: result += tp->t_movement; /* now add in movement rate */
1421:
1422: /* Is the character slowed? */
1423: if (on(*tp, ISSLOW) || on(*tp, ISDANCE)) result *= 2;
1424:
1425: /* Is the character hasted? */
1426: if (on(*tp, ISHASTE)) result /= 2;
1427:
1428: /* We have a minimum of 1 */
1429: if (result < 1) result = 1;
1430:
1431: return(result);
1432: }
1433:
1434: /*
1435: * rndmove:
1436: * move in a random direction if the monster/person is confused
1437: */
1438:
1439: coord *
1440: rndmove(struct thing *who)
1441: {
1442: register int x, y;
1443: register int ex, ey, nopen = 0;
1444: static coord ret; /* what we will be returning */
1445: static coord dest;
1446:
1447: ret = who->t_pos;
1448: /*
1449: * Now go through the spaces surrounding the player and
1450: * set that place in the array to true if the space can be
1451: * moved into
1452: */
1453: ey = ret.y + 1;
1454: ex = ret.x + 1;
1455: for (y = who->t_pos.y - 1; y <= ey; y++)
1456: if (y > 0 && y < lines - 2)
1457: for (x = who->t_pos.x - 1; x <= ex; x++)
1458: {
1459: if (x < 0 || x >= cols)
1460: continue;
1461: if (step_ok(y, x, NOMONST, who) == TRUE)
1462: {
1463: dest.y = y;
1464: dest.x = x;
1465: if (!diag_ok(&who->t_pos, &dest, who))
1466: continue;
1467: if (rnd(++nopen) == 0)
1468: ret = dest;
1469: }
1470: }
1471: return &ret;
1472: }
1473:
1474:
1475:
1476: #define TRAPTYPES 9 /* 9 total trap types that can be set */
1477: #define WIZARDTRAPS 3 /* Only wizards can set 3 of these */
1478:
1479: static char *trap_types[TRAPTYPES] = {
1480: "Trap Door",
1481: "Bear Trap",
1482: "Sleep Trap",
1483: "Arrow Trap",
1484: "Teleport Trap",
1485: "Dart Trap",
1486: "Magic pool",
1487: "Maze Trap",
1488: "Trading Post"
1489: };
1490:
1491: #ifdef PC7300
1492: #define TRAPWIDTH 13 /* Length of longest named trap from above list */
1493: #define TRAPPREFIX 4 /* Length of prefix (eg. "[9] ") */
1494: static menu_t Display; /* The menu structure */
1495: static mitem_t Dispitems[TRAPTYPES+1]; /* Info for each line */
1496: static char Displines[TRAPTYPES+1][TRAPWIDTH+TRAPPREFIX+1];
1497: #endif
1498:
1499: /*
1500: * set_trap:
1501: * set a trap at (y, x) on screen.
1502: */
1503:
1504: void
1505: set_trap(struct thing *tp, int y, int x)
1506: {
1507: register bool is_player = (tp == &player);
1508: register int selection = rnd(TRAPTYPES-WIZARDTRAPS) + '1';
1509: register int i, num_traps;
1510: register char ch, och;
1511: int thief_bonus = 0;
1512: int s_dext;
1513:
1514: if (is_player && player.t_ctype != C_THIEF && player.t_ctype != C_ASSASIN) {
1515: msg("Only thieves and assassins can set traps.");
1516: return;
1517: }
1518: switch (och = CCHAR( mvinch(y, x) )) {
1519: case WALL:
1520: case FLOOR:
1521: case PASSAGE:
1522: break;
1523: default:
1524: if (is_player) msg("The trap failed!");
1525: return;
1526: }
1527:
1528: if (is_player) {
1529: int state = 0, /* 0 -> current screen, 1 -> prompt screen, 2 -> done */
1530: units; /* Number of movement units for the given trap */
1531:
1532: if (player.t_action == C_SETTRAP) {
1533: selection = player.t_selection;
1534: player.t_selection = 0;
1535: player.t_using = NULL;
1536: player.t_action = A_NIL;
1537: }
1538: else {
1539: msg("Which kind of trap do you wish to set? (* for a list): ");
1540: num_traps = TRAPTYPES - (wizard ? 0 : WIZARDTRAPS);
1541: do {
1542: selection = tolower(readchar());
1543: switch (selection) {
1544: case '*':
1545: if (state != 1) {
1546: #ifdef PC7300
1547: for (i=0; i<TRAPTYPES; i++) {
1548: /*
1549: * Add numbers so the player can use a
1550: * number later, if he knows it. Let's
1551: * put the number on here instead of in
1552: * trap_types in case we want to drop it
1553: * later.
1554: */
1555: sprintf(Displines[i], "[%d] %s",
1556: i+1, trap_types[i]);
1557: Dispitems[i].mi_name = Displines[i];
1558: Dispitems[i].mi_flags = 0;
1559: Dispitems[i].mi_val = i+'1';
1560: }
1561:
1562: /* Place an end marker for the items */
1563: Dispitems[num_traps].mi_name = 0;
1564:
1565: /* Set up the main menu structure */
1566: Display.m_label = "Trap Creation";
1567: Display.m_title = "Trap Types";
1568: Display.m_prompt = "Select a trap type or press Cancl.";
1569: Display.m_curptr = '\0';
1570: Display.m_markptr = '\0';
1571: Display.m_flags = 0;
1572: Display.m_selcnt = 1;
1573: Display.m_items = Dispitems;
1574: Display.m_curi = 0;
1575:
1576: /*
1577: * Try to display the menu. If we don't have a local
1578: * terminal, the call will fail and we will just
1579: * continue with the normal mode.
1580: */
1581: if (menu(&Display) >= 0) {
1582: if (Display.m_selcnt == 0) {
1583: /* Cancelled menu */
1584: msg("");
1585:
1586: trap_tries--; /* Don't count this one */
1587: after = FALSE;
1588: return;
1589: }
1590: selection = Display.m_curi->mi_val;
1591: state = 2;
1592: break;
1593: }
1594: #endif
1595:
1596: wclear(hw);
1597: touchwin(hw);
1598: for (i=0; i<num_traps; i++) {
1599: wmove(hw, i+2, 0);
1600: wprintw(hw, "[%d] %s", i+1, trap_types[i]);
1601: }
1602: mvwaddstr(hw, 0, 0,
1603: "Which kind of trap do you wish to set? ");
1604:
1605: if (menu_overlay)
1606: /*
1607: * Put out the selection. The longest line is
1608: * the prompt line (39 characters long).
1609: */
1610: over_win(cw, hw, num_traps + 3, 41, 0, 39, '\0');
1611: else
1612: draw(hw);
1613: state = 1; /* Now in prompt window */
1614: }
1615: break;
1616:
1617: case ESCAPE:
1618: if (state == 1) {
1619: clearok(cw, FALSE); /* Set up for redraw */
1620: touchwin(cw);
1621: }
1622: msg("");
1623:
1624: trap_tries--; /* Don't count this one */
1625: after = FALSE;
1626: return;
1627:
1628: case '1':
1629: case '2':
1630: case '3':
1631: case '4':
1632: case '5':
1633: case '6':
1634: case '7':
1635: case '8':
1636: case '9':
1637: if (selection < '7' || wizard) {
1638: if (state == 1) { /* In prompt window */
1639: clearok(cw, FALSE); /* Set up for redraw */
1640: touchwin(cw);
1641: }
1642:
1643: msg("");
1644:
1645: /*
1646: * Make sure there is a floor below us for trap
1647: * doors.
1648: */
1649: if (selection == '1' && level >= nfloors) {
1650: if (state == 1) draw(cw);
1651: msg("There is no level below this one.");
1652: return;
1653: }
1654: state = 2; /* Finished */
1655: break;
1656: }
1657:
1658: /* Fall through for non-wizard, unusual trap case */
1659: default:
1660: if (state == 1) { /* In the prompt window */
1661: wmove(hw, 0, 0);
1662: wprintw(hw,
1663: "Please enter a selection between 1 and %d: ",
1664: num_traps);
1665: if (menu_overlay)
1666: /*
1667: * Put out the selection. The longest line is
1668: * the prompt line (43 characters long).
1669: */
1670: over_win(cw, hw, num_traps+3, 45, 0, 43, '\0');
1671: else
1672: draw(hw);
1673: }
1674: else { /* Normal window */
1675: mpos = 0;
1676: msg("Please enter a selection between 1 and %d: ",
1677: num_traps);
1678: }
1679: }
1680: } while (state != 2);
1681:
1682: switch ((player.t_selection = selection)) {
1683: case '1': units = 20; /* Trap door */
1684: when '2': units = 5; /* Bear trap */
1685: when '3': units = 6; /* Sleeping gas trap */
1686: when '4': units = 5; /* Arrow trap */
1687: when '5': units = 8; /* Teleport trap */
1688: when '6': units = 5; /* Dart trap */
1689: otherwise: units = 10; /* Unknown trap */
1690: }
1691: player.t_no_move = units * movement(&player);
1692: player.t_action = C_SETTRAP;
1693: player.t_using = NULL;
1694: return;
1695: }
1696: }
1697:
1698: if (is_player && player.t_ctype == C_THIEF) thief_bonus = 30;
1699: if (is_player && player.t_ctype == C_ASSASIN) thief_bonus = 20;
1700:
1701: s_dext = (tp == &player) ? dex_compute() : tp->t_stats.s_dext;
1702:
1703: if (ntraps >= MAXTRAPS || ++trap_tries >= MAXTRPTRY || levtype == POSTLEV ||
1704: rnd(80) >= (s_dext + tp->t_stats.s_lvl/2 + thief_bonus)) {
1705: if (is_player) msg("The trap failed!");
1706: return;
1707: }
1708:
1709: switch (selection) {
1710: case '1': ch = TRAPDOOR;
1711: when '2': ch = BEARTRAP;
1712: when '3': ch = SLEEPTRAP;
1713: when '4': ch = ARROWTRAP;
1714: when '5': ch = TELTRAP;
1715: when '6': ch = DARTTRAP;
1716: when '7': ch = POOL;
1717: when '8': ch = MAZETRAP;
1718: when '9': ch = POST;
1719: }
1720:
1721: mvaddch(y, x, ch);
1722: traps[ntraps].tr_show = och;
1723: traps[ntraps].tr_type = ch;
1724: traps[ntraps].tr_pos.y = y;
1725: traps[ntraps].tr_pos.x = x;
1726: if (is_player)
1727: traps[ntraps].tr_flags = ISTHIEFSET;
1728: if (ch == POOL || ch == POST) {
1729: traps[ntraps].tr_flags |= ISFOUND;
1730: }
1731:
1732: ntraps++;
1733: }
1734:
1735: /*
1736: * show:
1737: * returns what a certain thing will display as to the un-initiated
1738: */
1739:
1740: char
1741: show(int y, int x)
1742: {
1743: register char ch = CCHAR( winat(y, x) );
1744: register struct linked_list *it;
1745: register struct thing *tp;
1746:
1747: if (isatrap(ch)) {
1748: register struct trap *trp = trap_at(y, x);
1749:
1750: return (trp->tr_flags & ISFOUND) ? ch : trp->tr_show;
1751: }
1752: else if (isalpha(ch)) {
1753: if ((it = find_mons(y, x)) == NULL) {
1754: msg("Show: Can't find monster in show (%d, %d)", y, x);
1755: return(mvwinch(stdscr, y, x));
1756: }
1757: tp = THINGPTR(it);
1758:
1759: if (on(*tp, ISDISGUISE)) ch = tp->t_disguise; /* As a mimic */
1760:
1761: /* Hide invisible creatures */
1762: else if (invisible(tp)) {
1763: /* We can't see surprise-type creatures through "see invisible" */
1764: if (off(player,CANSEE) || on(*tp,CANSURPRISE))
1765: ch = CCHAR( mvwinch(stdscr, y, x) ); /* Invisible */
1766: }
1767: else if (on(*tp, CANINWALL)) {
1768: if (isrock(mvwinch(stdscr, y, x))) ch = CCHAR( winch(stdscr) ); /* As Xorn */
1769: }
1770: }
1771: return ch;
1772: }
1773:
1774:
1775: /*
1776: * trap_at:
1777: * find the trap at (y,x) on screen.
1778: */
1779:
1780: struct trap *
1781: trap_at(int y, int x)
1782: {
1783: register struct trap *tp, *ep;
1784:
1785: ep = &traps[ntraps];
1786: for (tp = traps; tp < ep; tp++)
1787: if (tp->tr_pos.y == y && tp->tr_pos.x == x)
1788: break;
1789: if (tp == ep)
1790: debug((sprintf(prbuf, "Trap at %d,%d not in array", y, x), prbuf));
1791: return tp;
1792: }
1793:
1794: /*
1795: * weap_move:
1796: * Calculate how many segments it will take to swing the given
1797: * weapon (note that the weapon may actually be a stick or
1798: * even something else).
1799: * wielder: Who's wielding the weapon
1800: * weap: The weapon
1801: */
1802:
1803: int
1804: weap_move(struct thing *wielder, struct object *weap)
1805: {
1806: register int weap_rate;
1807: int dexterity;
1808: int strength;
1809:
1810: if (weap == NULL) return(1); /* hand, claw, bite attacks are quick */
1811:
1812: switch (weap->o_type) {
1813: case STICK:
1814: if (EQUAL(ws_type[weap->o_which], "staff"))
1815: weap_rate = 2;
1816: else weap_rate = 1; /* A wand */
1817:
1818: when WEAPON:
1819: weap_rate = weaps[weap->o_which].w_rate;
1820:
1821: /* Adjust for blessed or cursed weapon */
1822: if (weap->o_hplus < 0) /* Cursed */
1823: weap_rate -= (weap->o_hplus - 2) / 3;
1824: else if (weap_rate > 0) /* Blessed */
1825: weap_rate -= (2*weap->o_hplus + weap_rate - 1) / weap_rate;
1826:
1827: when RELIC:
1828: switch (weap->o_which) {
1829: case MUSTY_DAGGER:
1830: case HRUGGEK_MSTAR:
1831: case AXE_AKLAD:
1832: case YEENOGHU_FLAIL:
1833: case MING_STAFF:
1834: case ORCUS_WAND:
1835: case ASMO_ROD:
1836: /* These operate in the blink of an eye */
1837: weap_rate = 1;
1838: otherwise:
1839: /* What is it? */
1840: weap_rate = 10;
1841: debug("unknown weapon in weap_move()");
1842: }
1843: otherwise:
1844: /* What is it? */
1845: weap_rate = 10;
1846: debug("unknown weapon in weap_move()");
1847: }
1848:
1849: /* Put in a dexterity bonus */
1850: if (wielder == &player) dexterity = dex_compute();
1851: else dexterity = wielder->t_stats.s_dext;
1852: weap_rate -= dext_plus(dexterity) / 2;
1853:
1854: /* Put in a strength bonus */
1855: if (wielder == &player) strength = str_compute();
1856: else strength = wielder->t_stats.s_str;
1857: weap_rate -= str_plus(strength) / 2;
1858:
1859: /* It can't speed you up and it must take SOME time */
1860: if (weap_rate <= 0) weap_rate = 1;
1861:
1862: /* Do we need to adjust for fast/slow movement? */
1863: if (on(*wielder, ISSLOW) || on(*wielder, ISDANCE)) weap_rate *= 2;
1864: if (on(*wielder, ISHASTE)) weap_rate /= 2;
1865:
1866: /* Return the result */
1867: return(weap_rate);
1868: }