![[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 [CSRG BSD Unix] / 43BSDTahoe / games / rogue|
Return to move.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / games / rogue |
1.1 root 1: /*
2: * move.c
3: *
4: * This source herein may be modified and/or distributed by anybody who
5: * so desires, with the following restrictions:
6: * 1.) No portion of this notice shall be removed.
7: * 2.) Credit shall not be taken for the creation of this source.
8: * 3.) This code is not to be traded, sold, or used for personal
9: * gain or profit.
10: *
11: */
12:
13: #ifndef lint
14: static char sccsid[] = "@(#)move.c 5.1 (Berkeley) 11/25/87";
15: #endif /* not lint */
16:
17: #include "rogue.h"
18:
19: short m_moves = 0;
20: boolean jump = 0;
21: char *you_can_move_again = "you can move again";
22:
23: extern short cur_room, halluc, blind, levitate;
24: extern short cur_level, max_level;
25: extern short bear_trap, haste_self, confused;
26: extern short e_rings, regeneration, auto_search;
27: extern char hunger_str[];
28: extern boolean being_held, interrupted, r_teleport, passgo;
29:
30: one_move_rogue(dirch, pickup)
31: short dirch, pickup;
32: {
33: short row, col;
34: object *obj;
35: char desc[DCOLS];
36: short n, status, d;
37:
38: row = rogue.row;
39: col = rogue.col;
40:
41: if (confused) {
42: dirch = gr_dir();
43: }
44: (void) is_direction(dirch, &d);
45: get_dir_rc(d, &row, &col, 1);
46:
47: if (!can_move(rogue.row, rogue.col, row, col)) {
48: return(MOVE_FAILED);
49: }
50: if (being_held || bear_trap) {
51: if (!(dungeon[row][col] & MONSTER)) {
52: if (being_held) {
53: message("you are being held", 1);
54: } else {
55: message("you are still stuck in the bear trap", 0);
56: (void) reg_move();
57: }
58: return(MOVE_FAILED);
59: }
60: }
61: if (r_teleport) {
62: if (rand_percent(R_TELE_PERCENT)) {
63: tele();
64: return(STOPPED_ON_SOMETHING);
65: }
66: }
67: if (dungeon[row][col] & MONSTER) {
68: rogue_hit(object_at(&level_monsters, row, col), 0);
69: (void) reg_move();
70: return(MOVE_FAILED);
71: }
72: if (dungeon[row][col] & DOOR) {
73: if (cur_room == PASSAGE) {
74: cur_room = get_room_number(row, col);
75: light_up_room(cur_room);
76: wake_room(cur_room, 1, row, col);
77: } else {
78: light_passage(row, col);
79: }
80: } else if ((dungeon[rogue.row][rogue.col] & DOOR) &&
81: (dungeon[row][col] & TUNNEL)) {
82: light_passage(row, col);
83: wake_room(cur_room, 0, rogue.row, rogue.col);
84: darken_room(cur_room);
85: cur_room = PASSAGE;
86: } else if (dungeon[row][col] & TUNNEL) {
87: light_passage(row, col);
88: }
89: mvaddch(rogue.row, rogue.col, get_dungeon_char(rogue.row, rogue.col));
90: mvaddch(row, col, rogue.fchar);
91:
92: if (!jump) {
93: refresh();
94: }
95: rogue.row = row;
96: rogue.col = col;
97: if (dungeon[row][col] & OBJECT) {
98: if (levitate && pickup) {
99: return(STOPPED_ON_SOMETHING);
100: }
101: if (pickup && !levitate) {
102: if (obj = pick_up(row, col, &status)) {
103: get_desc(obj, desc);
104: if (obj->what_is == GOLD) {
105: free_object(obj);
106: goto NOT_IN_PACK;
107: }
108: } else if (!status) {
109: goto MVED;
110: } else {
111: goto MOVE_ON;
112: }
113: } else {
114: MOVE_ON:
115: obj = object_at(&level_objects, row, col);
116: (void) strcpy(desc, "moved onto ");
117: get_desc(obj, desc+11);
118: goto NOT_IN_PACK;
119: }
120: n = strlen(desc);
121: desc[n] = '(';
122: desc[n+1] = obj->ichar;
123: desc[n+2] = ')';
124: desc[n+3] = 0;
125: NOT_IN_PACK:
126: message(desc, 1);
127: (void) reg_move();
128: return(STOPPED_ON_SOMETHING);
129: }
130: if (dungeon[row][col] & (DOOR | STAIRS | TRAP)) {
131: if ((!levitate) && (dungeon[row][col] & TRAP)) {
132: trap_player(row, col);
133: }
134: (void) reg_move();
135: return(STOPPED_ON_SOMETHING);
136: }
137: MVED: if (reg_move()) { /* fainted from hunger */
138: return(STOPPED_ON_SOMETHING);
139: }
140: return((confused ? STOPPED_ON_SOMETHING : MOVED));
141: }
142:
143: multiple_move_rogue(dirch)
144: short dirch;
145: {
146: short row, col;
147: short m;
148:
149: switch(dirch) {
150: case '\010':
151: case '\012':
152: case '\013':
153: case '\014':
154: case '\031':
155: case '\025':
156: case '\016':
157: case '\002':
158: do {
159: row = rogue.row;
160: col = rogue.col;
161: if (((m = one_move_rogue((dirch + 96), 1)) == MOVE_FAILED) ||
162: (m == STOPPED_ON_SOMETHING) ||
163: interrupted) {
164: break;
165: }
166: } while (!next_to_something(row, col));
167: if ( (!interrupted) && passgo && (m == MOVE_FAILED) &&
168: (dungeon[rogue.row][rogue.col] & TUNNEL)) {
169: turn_passage(dirch + 96, 0);
170: }
171: break;
172: case 'H':
173: case 'J':
174: case 'K':
175: case 'L':
176: case 'B':
177: case 'Y':
178: case 'U':
179: case 'N':
180: while ((!interrupted) && (one_move_rogue((dirch + 32), 1) == MOVED)) ;
181:
182: if ( (!interrupted) && passgo &&
183: (dungeon[rogue.row][rogue.col] & TUNNEL)) {
184: turn_passage(dirch + 32, 1);
185: }
186: break;
187: }
188: }
189:
190: is_passable(row, col)
191: register row, col;
192: {
193: if ((row < MIN_ROW) || (row > (DROWS - 2)) || (col < 0) ||
194: (col > (DCOLS-1))) {
195: return(0);
196: }
197: if (dungeon[row][col] & HIDDEN) {
198: return((dungeon[row][col] & TRAP) ? 1 : 0);
199: }
200: return(dungeon[row][col] & (FLOOR | TUNNEL | DOOR | STAIRS | TRAP));
201: }
202:
203: next_to_something(drow, dcol)
204: register drow, dcol;
205: {
206: short i, j, i_end, j_end, row, col;
207: short pass_count = 0;
208: unsigned short s;
209:
210: if (confused) {
211: return(1);
212: }
213: if (blind) {
214: return(0);
215: }
216: i_end = (rogue.row < (DROWS-2)) ? 1 : 0;
217: j_end = (rogue.col < (DCOLS-1)) ? 1 : 0;
218:
219: for (i = ((rogue.row > MIN_ROW) ? -1 : 0); i <= i_end; i++) {
220: for (j = ((rogue.col > 0) ? -1 : 0); j <= j_end; j++) {
221: if ((i == 0) && (j == 0)) {
222: continue;
223: }
224: if (((rogue.row+i) == drow) && ((rogue.col+j) == dcol)) {
225: continue;
226: }
227: row = rogue.row + i;
228: col = rogue.col + j;
229: s = dungeon[row][col];
230: if (s & HIDDEN) {
231: continue;
232: }
233: /* If the rogue used to be right, up, left, down, or right of
234: * row,col, and now isn't, then don't stop */
235: if (s & (MONSTER | OBJECT | STAIRS)) {
236: if (((row == drow) || (col == dcol)) &&
237: (!((row == rogue.row) || (col == rogue.col)))) {
238: continue;
239: }
240: return(1);
241: }
242: if (s & TRAP) {
243: if (!(s & HIDDEN)) {
244: if (((row == drow) || (col == dcol)) &&
245: (!((row == rogue.row) || (col == rogue.col)))) {
246: continue;
247: }
248: return(1);
249: }
250: }
251: if ((((i - j) == 1) || ((i - j) == -1)) && (s & TUNNEL)) {
252: if (++pass_count > 1) {
253: return(1);
254: }
255: }
256: if ((s & DOOR) && ((i == 0) || (j == 0))) {
257: return(1);
258: }
259: }
260: }
261: return(0);
262: }
263:
264: can_move(row1, col1, row2, col2)
265: {
266: if (!is_passable(row2, col2)) {
267: return(0);
268: }
269: if ((row1 != row2) && (col1 != col2)) {
270: if ((dungeon[row1][col1] & DOOR) || (dungeon[row2][col2] & DOOR)) {
271: return(0);
272: }
273: if ((!dungeon[row1][col2]) || (!dungeon[row2][col1])) {
274: return(0);
275: }
276: }
277: return(1);
278: }
279:
280: move_onto()
281: {
282: short ch, d;
283: boolean first_miss = 1;
284:
285: while (!is_direction(ch = rgetchar(), &d)) {
286: sound_bell();
287: if (first_miss) {
288: message("direction? ", 0);
289: first_miss = 0;
290: }
291: }
292: check_message();
293: if (ch != CANCEL) {
294: (void) one_move_rogue(ch, 0);
295: }
296: }
297:
298: boolean
299: is_direction(c, d)
300: short c;
301: short *d;
302: {
303: switch(c) {
304: case 'h':
305: *d = LEFT;
306: break;
307: case 'j':
308: *d = DOWN;
309: break;
310: case 'k':
311: *d = UPWARD;
312: break;
313: case 'l':
314: *d = RIGHT;
315: break;
316: case 'b':
317: *d = DOWNLEFT;
318: break;
319: case 'y':
320: *d = UPLEFT;
321: break;
322: case 'u':
323: *d = UPRIGHT;
324: break;
325: case 'n':
326: *d = DOWNRIGHT;
327: break;
328: case CANCEL:
329: break;
330: default:
331: return(0);
332: }
333: return(1);
334: }
335:
336: boolean
337: check_hunger(msg_only)
338: boolean msg_only;
339: {
340: register short i, n;
341: boolean fainted = 0;
342:
343: if (rogue.moves_left == HUNGRY) {
344: (void) strcpy(hunger_str, "hungry");
345: message(hunger_str, 0);
346: print_stats(STAT_HUNGER);
347: }
348: if (rogue.moves_left == WEAK) {
349: (void) strcpy(hunger_str, "weak");
350: message(hunger_str, 1);
351: print_stats(STAT_HUNGER);
352: }
353: if (rogue.moves_left <= FAINT) {
354: if (rogue.moves_left == FAINT) {
355: (void) strcpy(hunger_str, "faint");
356: message(hunger_str, 1);
357: print_stats(STAT_HUNGER);
358: }
359: n = get_rand(0, (FAINT - rogue.moves_left));
360: if (n > 0) {
361: fainted = 1;
362: if (rand_percent(40)) {
363: rogue.moves_left++;
364: }
365: message("you faint", 1);
366: for (i = 0; i < n; i++) {
367: if (coin_toss()) {
368: mv_mons();
369: }
370: }
371: message(you_can_move_again, 1);
372: }
373: }
374: if (msg_only) {
375: return(fainted);
376: }
377: if (rogue.moves_left <= STARVE) {
378: killed_by((object *) 0, STARVATION);
379: }
380:
381: switch(e_rings) {
382: /*case -2:
383: Subtract 0, i.e. do nothing.
384: break;*/
385: case -1:
386: rogue.moves_left -= (rogue.moves_left % 2);
387: break;
388: case 0:
389: rogue.moves_left--;
390: break;
391: case 1:
392: rogue.moves_left--;
393: (void) check_hunger(1);
394: rogue.moves_left -= (rogue.moves_left % 2);
395: break;
396: case 2:
397: rogue.moves_left--;
398: (void) check_hunger(1);
399: rogue.moves_left--;
400: break;
401: }
402: return(fainted);
403: }
404:
405: boolean
406: reg_move()
407: {
408: boolean fainted;
409:
410: if ((rogue.moves_left <= HUNGRY) || (cur_level >= max_level)) {
411: fainted = check_hunger(0);
412: } else {
413: fainted = 0;
414: }
415:
416: mv_mons();
417:
418: if (++m_moves >= 120) {
419: m_moves = 0;
420: wanderer();
421: }
422: if (halluc) {
423: if (!(--halluc)) {
424: unhallucinate();
425: } else {
426: hallucinate();
427: }
428: }
429: if (blind) {
430: if (!(--blind)) {
431: unblind();
432: }
433: }
434: if (confused) {
435: if (!(--confused)) {
436: unconfuse();
437: }
438: }
439: if (bear_trap) {
440: bear_trap--;
441: }
442: if (levitate) {
443: if (!(--levitate)) {
444: message("you float gently to the ground", 1);
445: if (dungeon[rogue.row][rogue.col] & TRAP) {
446: trap_player(rogue.row, rogue.col);
447: }
448: }
449: }
450: if (haste_self) {
451: if (!(--haste_self)) {
452: message("you feel yourself slowing down", 0);
453: }
454: }
455: heal();
456: if (auto_search > 0) {
457: search(auto_search, auto_search);
458: }
459: return(fainted);
460: }
461:
462: rest(count)
463: {
464: int i;
465:
466: interrupted = 0;
467:
468: for (i = 0; i < count; i++) {
469: if (interrupted) {
470: break;
471: }
472: (void) reg_move();
473: }
474: }
475:
476: gr_dir()
477: {
478: short d;
479:
480: d = get_rand(1, 8);
481:
482: switch(d) {
483: case 1:
484: d = 'j';
485: break;
486: case 2:
487: d = 'k';
488: break;
489: case 3:
490: d = 'l';
491: break;
492: case 4:
493: d = 'h';
494: break;
495: case 5:
496: d = 'y';
497: break;
498: case 6:
499: d = 'u';
500: break;
501: case 7:
502: d = 'b';
503: break;
504: case 8:
505: d = 'n';
506: break;
507: }
508: return(d);
509: }
510:
511: heal()
512: {
513: static short heal_exp = -1, n, c = 0;
514: static boolean alt;
515:
516: if (rogue.hp_current == rogue.hp_max) {
517: c = 0;
518: return;
519: }
520: if (rogue.exp != heal_exp) {
521: heal_exp = rogue.exp;
522:
523: switch(heal_exp) {
524: case 1:
525: n = 20;
526: break;
527: case 2:
528: n = 18;
529: break;
530: case 3:
531: n = 17;
532: break;
533: case 4:
534: n = 14;
535: break;
536: case 5:
537: n = 13;
538: break;
539: case 6:
540: n = 10;
541: break;
542: case 7:
543: n = 9;
544: break;
545: case 8:
546: n = 8;
547: break;
548: case 9:
549: n = 7;
550: break;
551: case 10:
552: n = 4;
553: break;
554: case 11:
555: n = 3;
556: break;
557: case 12:
558: default:
559: n = 2;
560: }
561: }
562: if (++c >= n) {
563: c = 0;
564: rogue.hp_current++;
565: if (alt = !alt) {
566: rogue.hp_current++;
567: }
568: if ((rogue.hp_current += regeneration) > rogue.hp_max) {
569: rogue.hp_current = rogue.hp_max;
570: }
571: print_stats(STAT_HP);
572: }
573: }
574:
575: static boolean
576: can_turn(nrow, ncol)
577: short nrow, ncol;
578: {
579: if ((dungeon[nrow][ncol] & TUNNEL) && is_passable(nrow, ncol)) {
580: return(1);
581: }
582: return(0);
583: }
584:
585: turn_passage(dir, fast)
586: short dir;
587: boolean fast;
588: {
589: short crow = rogue.row, ccol = rogue.col, turns = 0;
590: short ndir;
591:
592: if ((dir != 'h') && can_turn(crow, ccol + 1)) {
593: turns++;
594: ndir = 'l';
595: }
596: if ((dir != 'l') && can_turn(crow, ccol - 1)) {
597: turns++;
598: ndir = 'h';
599: }
600: if ((dir != 'k') && can_turn(crow + 1, ccol)) {
601: turns++;
602: ndir = 'j';
603: }
604: if ((dir != 'j') && can_turn(crow - 1, ccol)) {
605: turns++;
606: ndir = 'k';
607: }
608: if (turns == 1) {
609: multiple_move_rogue(ndir - (fast ? 32 : 96));
610: }
611: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.