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