-WARNS6 cleanups (3953 warnings)
[dragonfly.git] / games / rogue / move.c
1 /*
2  * Copyright (c) 1988, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * Timothy C. Stoehr.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *      This product includes software developed by the University of
19  *      California, Berkeley and its contributors.
20  * 4. Neither the name of the University nor the names of its contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  *
36  * @(#)move.c   8.1 (Berkeley) 5/31/93
37  * $FreeBSD: src/games/rogue/move.c,v 1.7 1999/11/30 03:49:24 billf Exp $
38  * $DragonFly: src/games/rogue/move.c,v 1.4 2006/09/02 19:31:07 pavalos Exp $
39  */
40
41 /*
42  * move.c
43  *
44  * This source herein may be modified and/or distributed by anybody who
45  * so desires, with the following restrictions:
46  *    1.)  No portion of this notice shall be removed.
47  *    2.)  Credit shall not be taken for the creation of this source.
48  *    3.)  This code is not to be traded, sold, or used for personal
49  *         gain or profit.
50  *
51  */
52
53 #include "rogue.h"
54
55 short m_moves = 0;
56 boolean jump = 0;
57 const char *you_can_move_again = "you can move again";
58
59 extern short cur_room, halluc, blind, levitate;
60 extern short cur_level, max_level;
61 extern short bear_trap, haste_self, confused;
62 extern short e_rings, regeneration, auto_search;
63 extern boolean being_held, interrupted, r_teleport, passgo;
64
65 static boolean  next_to_something(int, int);
66 static boolean  check_hunger(boolean);
67 static short    gr_dir(void);
68 static void     heal(void);
69 static boolean  can_turn(short, short);
70 static void     turn_passage(short, boolean);
71
72 short
73 one_move_rogue(short dirch, short pickup)
74 {
75         short row, col;
76         object *obj;
77         char desc[DCOLS];
78         short n, status, d;
79
80         row = rogue.row;
81         col = rogue.col;
82
83         if (confused) {
84                 dirch = gr_dir();
85         }
86         is_direction(dirch, &d);
87         get_dir_rc(d, &row, &col, 1);
88
89         if (!can_move(rogue.row, rogue.col, row, col)) {
90                 return(MOVE_FAILED);
91         }
92         if (being_held || bear_trap) {
93                 if (!(dungeon[row][col] & MONSTER)) {
94                         if (being_held) {
95                                 message("you are being held", 1);
96                         } else {
97                                 message("you are still stuck in the bear trap", 0);
98                                 reg_move();
99                         }
100                         return(MOVE_FAILED);
101                 }
102         }
103         if (r_teleport) {
104                 if (rand_percent(R_TELE_PERCENT)) {
105                         tele();
106                         return(STOPPED_ON_SOMETHING);
107                 }
108         }
109         if (dungeon[row][col] & MONSTER) {
110                 rogue_hit(object_at(&level_monsters, row, col), 0);
111                 reg_move();
112                 return(MOVE_FAILED);
113         }
114         if (dungeon[row][col] & DOOR) {
115                 if (cur_room == PASSAGE) {
116                         cur_room = get_room_number(row, col);
117                         light_up_room(cur_room);
118                         wake_room(cur_room, 1, row, col);
119                 } else {
120                         light_passage(row, col);
121                 }
122         } else if ((dungeon[rogue.row][rogue.col] & DOOR) &&
123                    (dungeon[row][col] & TUNNEL)) {
124                 light_passage(row, col);
125                 wake_room(cur_room, 0, rogue.row, rogue.col);
126                 darken_room(cur_room);
127                 cur_room = PASSAGE;
128         } else if (dungeon[row][col] & TUNNEL) {
129                         light_passage(row, col);
130         }
131         mvaddch(rogue.row, rogue.col, get_dungeon_char(rogue.row, rogue.col));
132         mvaddch(row, col, rogue.fchar);
133
134         if (!jump) {
135                 refresh();
136         }
137         rogue.row = row;
138         rogue.col = col;
139         if (dungeon[row][col] & OBJECT) {
140                 if (levitate && pickup) {
141                         return(STOPPED_ON_SOMETHING);
142                 }
143                 if (pickup && !levitate) {
144                         if ((obj = pick_up(row, col, &status))) {
145                                 get_desc(obj, desc);
146                                 if (obj->what_is == GOLD) {
147                                         free_object(obj);
148                                         goto NOT_IN_PACK;
149                                 }
150                         } else if (!status) {
151                                 goto MVED;
152                         } else {
153                                 goto MOVE_ON;
154                         }
155                 } else {
156 MOVE_ON:
157                         obj = object_at(&level_objects, row, col);
158                         strcpy(desc, "moved onto ");
159                         get_desc(obj, desc+11);
160                         goto NOT_IN_PACK;
161                 }
162                 n = strlen(desc);
163                 desc[n] = '(';
164                 desc[n+1] = obj->ichar;
165                 desc[n+2] = ')';
166                 desc[n+3] = 0;
167 NOT_IN_PACK:
168                 message(desc, 1);
169                 reg_move();
170                 return(STOPPED_ON_SOMETHING);
171         }
172         if (dungeon[row][col] & (DOOR | STAIRS | TRAP)) {
173                 if ((!levitate) && (dungeon[row][col] & TRAP)) {
174                         trap_player(row, col);
175                 }
176                 reg_move();
177                 return(STOPPED_ON_SOMETHING);
178         }
179 MVED:   if (reg_move()) {                       /* fainted from hunger */
180                         return(STOPPED_ON_SOMETHING);
181         }
182         return((confused ? STOPPED_ON_SOMETHING : MOVED));
183 }
184
185 void
186 multiple_move_rogue(short dirch)
187 {
188         short row, col;
189         short m;
190
191         switch(dirch) {
192         case '\010':
193         case '\012':
194         case '\013':
195         case '\014':
196         case '\031':
197         case '\025':
198         case '\016':
199         case '\002':
200                 do {
201                         row = rogue.row;
202                         col = rogue.col;
203                         if (((m = one_move_rogue((dirch + 96), 1)) == MOVE_FAILED) ||
204                                 (m == STOPPED_ON_SOMETHING) ||
205                                 interrupted) {
206                                 break;
207                         }
208                 } while (!next_to_something(row, col));
209                 if (    (!interrupted) && passgo && (m == MOVE_FAILED) &&
210                                 (dungeon[rogue.row][rogue.col] & TUNNEL)) {
211                         turn_passage(dirch + 96, 0);
212                 }
213                 break;
214         case 'H':
215         case 'J':
216         case 'K':
217         case 'L':
218         case 'B':
219         case 'Y':
220         case 'U':
221         case 'N':
222                 while ((!interrupted) && (one_move_rogue((dirch + 32), 1) == MOVED)) ;
223
224                 if (    (!interrupted) && passgo &&
225                                 (dungeon[rogue.row][rogue.col] & TUNNEL)) {
226                         turn_passage(dirch + 32, 1);
227                 }
228                 break;
229         }
230 }
231
232 boolean
233 is_passable(int row, int col)
234 {
235         if ((row < MIN_ROW) || (row > (DROWS - 2)) || (col < 0) ||
236                 (col > (DCOLS-1))) {
237                 return(0);
238         }
239         if (dungeon[row][col] & HIDDEN) {
240                 return((dungeon[row][col] & TRAP) ? 1 : 0);
241         }
242         return(dungeon[row][col] & (FLOOR | TUNNEL | DOOR | STAIRS | TRAP));
243 }
244
245 static boolean
246 next_to_something(int drow, int dcol)
247 {
248         short i, j, i_end, j_end, row, col;
249         short pass_count = 0;
250         unsigned short s;
251
252         if (confused) {
253                 return(1);
254         }
255         if (blind) {
256                 return(0);
257         }
258         i_end = (rogue.row < (DROWS-2)) ? 1 : 0;
259         j_end = (rogue.col < (DCOLS-1)) ? 1 : 0;
260
261         for (i = ((rogue.row > MIN_ROW) ? -1 : 0); i <= i_end; i++) {
262                 for (j = ((rogue.col > 0) ? -1 : 0); j <= j_end; j++) {
263                         if ((i == 0) && (j == 0)) {
264                                 continue;
265                         }
266                         if (((rogue.row+i) == drow) && ((rogue.col+j) == dcol)) {
267                                 continue;
268                         }
269                         row = rogue.row + i;
270                         col = rogue.col + j;
271                         s = dungeon[row][col];
272                         if (s & HIDDEN) {
273                                 continue;
274                         }
275                         /* If the rogue used to be right, up, left, down, or right of
276                          * row,col, and now isn't, then don't stop */
277                         if (s & (MONSTER | OBJECT | STAIRS)) {
278                                 if (((row == drow) || (col == dcol)) &&
279                                         (!((row == rogue.row) || (col == rogue.col)))) {
280                                         continue;
281                                 }
282                                 return(1);
283                         }
284                         if (s & TRAP) {
285                                 if (!(s & HIDDEN)) {
286                                         if (((row == drow) || (col == dcol)) &&
287                                                 (!((row == rogue.row) || (col == rogue.col)))) {
288                                                 continue;
289                                         }
290                                         return(1);
291                                 }
292                         }
293                         if ((((i - j) == 1) || ((i - j) == -1)) && (s & TUNNEL)) {
294                                 if (++pass_count > 1) {
295                                         return(1);
296                                 }
297                         }
298                         if ((s & DOOR) && ((i == 0) || (j == 0))) {
299                                         return(1);
300                         }
301                 }
302         }
303         return(0);
304 }
305
306 boolean
307 can_move(short row1, short col1, short row2, short col2)
308 {
309         if (!is_passable(row2, col2)) {
310                 return(0);
311         }
312         if ((row1 != row2) && (col1 != col2)) {
313                 if ((dungeon[row1][col1] & DOOR) || (dungeon[row2][col2] & DOOR)) {
314                         return(0);
315                 }
316                 if ((!dungeon[row1][col2]) || (!dungeon[row2][col1])) {
317                         return(0);
318                 }
319         }
320         return(1);
321 }
322
323 void
324 move_onto(void)
325 {
326         short ch, d;
327         boolean first_miss = 1;
328
329         while (!is_direction(ch = rgetchar(), &d)) {
330                 sound_bell();
331                 if (first_miss) {
332                         message("direction? ", 0);
333                         first_miss = 0;
334                 }
335         }
336         check_message();
337         if (ch != CANCEL) {
338                 one_move_rogue(ch, 0);
339         }
340 }
341
342 boolean
343 is_direction(short c, short *d)
344 {
345         switch(c) {
346         case 'h':
347                 *d = LEFT;
348                 break;
349         case 'j':
350                 *d = DOWN;
351                 break;
352         case 'k':
353                 *d = UPWARD;
354                 break;
355         case 'l':
356                 *d = RIGHT;
357                 break;
358         case 'b':
359                 *d = DOWNLEFT;
360                 break;
361         case 'y':
362                 *d = UPLEFT;
363                 break;
364         case 'u':
365                 *d = UPRIGHT;
366                 break;
367         case 'n':
368                 *d = DOWNRIGHT;
369                 break;
370         case CANCEL:
371                 break;
372         default:
373                 return(0);
374         }
375         return(1);
376 }
377
378 static boolean
379 check_hunger(boolean msg_only)
380 {
381         short i, n;
382         boolean fainted = 0;
383
384         if (rogue.moves_left == HUNGRY) {
385                 strcpy(hunger_str, "hungry");
386                 message(hunger_str, 0);
387                 print_stats(STAT_HUNGER);
388         }
389         if (rogue.moves_left == WEAK) {
390                 strcpy(hunger_str, "weak");
391                 message(hunger_str, 1);
392                 print_stats(STAT_HUNGER);
393         }
394         if (rogue.moves_left <= FAINT) {
395                 if (rogue.moves_left == FAINT) {
396                         strcpy(hunger_str, "faint");
397                         message(hunger_str, 1);
398                         print_stats(STAT_HUNGER);
399                 }
400                 n = get_rand(0, (FAINT - rogue.moves_left));
401                 if (n > 0) {
402                         fainted = 1;
403                         if (rand_percent(40)) {
404                                 rogue.moves_left++;
405                         }
406                         message("you faint", 1);
407                         for (i = 0; i < n; i++) {
408                                 if (coin_toss()) {
409                                         mv_mons();
410                                 }
411                         }
412                         message(you_can_move_again, 1);
413                 }
414         }
415         if (msg_only) {
416                 return(fainted);
417         }
418         if (rogue.moves_left <= STARVE) {
419                 killed_by((object *) 0, STARVATION);
420         }
421
422         switch(e_rings) {
423         case -1:
424                 rogue.moves_left -= (rogue.moves_left % 2);
425                 break;
426         case 0:
427                 rogue.moves_left--;
428                 break;
429         case 1:
430                 rogue.moves_left--;
431                 check_hunger(1);
432                 rogue.moves_left -= (rogue.moves_left % 2);
433                 break;
434         case 2:
435                 rogue.moves_left--;
436                 check_hunger(1);
437                 rogue.moves_left--;
438                 break;
439         }
440         return(fainted);
441 }
442
443 boolean
444 reg_move(void)
445 {
446         boolean fainted;
447
448         if ((rogue.moves_left <= HUNGRY) || (cur_level >= max_level)) {
449                 fainted = check_hunger(0);
450         } else {
451                 fainted = 0;
452         }
453
454         mv_mons();
455
456         if (++m_moves >= 120) {
457                 m_moves = 0;
458                 wanderer();
459         }
460         if (halluc) {
461                 if (!(--halluc)) {
462                         unhallucinate();
463                 } else {
464                         hallucinate();
465                 }
466         }
467         if (blind) {
468                 if (!(--blind)) {
469                         unblind();
470                 }
471         }
472         if (confused) {
473                 if (!(--confused)) {
474                         unconfuse();
475                 }
476         }
477         if (bear_trap) {
478                 bear_trap--;
479         }
480         if (levitate) {
481                 if (!(--levitate)) {
482                         message("you float gently to the ground", 1);
483                         if (dungeon[rogue.row][rogue.col] & TRAP) {
484                                 trap_player(rogue.row, rogue.col);
485                         }
486                 }
487         }
488         if (haste_self) {
489                 if (!(--haste_self)) {
490                         message("you feel yourself slowing down", 0);
491                 }
492         }
493         heal();
494         if (auto_search > 0) {
495                 search(auto_search, auto_search);
496         }
497         return(fainted);
498 }
499
500 void
501 rest(int count)
502 {
503         int i;
504
505         interrupted = 0;
506
507         for (i = 0; i < count; i++) {
508                 if (interrupted) {
509                         break;
510                 }
511                 reg_move();
512         }
513 }
514
515 static short
516 gr_dir(void)
517 {
518         short d;
519
520         d = get_rand(1, 8);
521
522         switch(d) {
523                 case 1:
524                         d = 'j';
525                         break;
526                 case 2:
527                         d = 'k';
528                         break;
529                 case 3:
530                         d = 'l';
531                         break;
532                 case 4:
533                         d = 'h';
534                         break;
535                 case 5:
536                         d = 'y';
537                         break;
538                 case 6:
539                         d = 'u';
540                         break;
541                 case 7:
542                         d = 'b';
543                         break;
544                 case 8:
545                         d = 'n';
546                         break;
547         }
548         return(d);
549 }
550
551 static void
552 heal(void)
553 {
554         static short heal_exp = -1, n, c = 0;
555         static boolean alt;
556
557         if (rogue.hp_current == rogue.hp_max) {
558                 c = 0;
559                 return;
560         }
561         if (rogue.exp != heal_exp) {
562                 heal_exp = rogue.exp;
563
564                 switch(heal_exp) {
565                 case 1:
566                         n = 20;
567                         break;
568                 case 2:
569                         n = 18;
570                         break;
571                 case 3:
572                         n = 17;
573                         break;
574                 case 4:
575                         n = 14;
576                         break;
577                 case 5:
578                         n = 13;
579                         break;
580                 case 6:
581                         n = 10;
582                         break;
583                 case 7:
584                         n = 9;
585                         break;
586                 case 8:
587                         n = 8;
588                         break;
589                 case 9:
590                         n = 7;
591                         break;
592                 case 10:
593                         n = 4;
594                         break;
595                 case 11:
596                         n = 3;
597                         break;
598                 case 12:
599                 default:
600                         n = 2;
601                 }
602         }
603         if (++c >= n) {
604                 c = 0;
605                 rogue.hp_current++;
606                 if ((alt = !alt)) {
607                         rogue.hp_current++;
608                 }
609                 if ((rogue.hp_current += regeneration) > rogue.hp_max) {
610                         rogue.hp_current = rogue.hp_max;
611                 }
612                 print_stats(STAT_HP);
613         }
614 }
615
616 static boolean
617 can_turn(short nrow, short ncol)
618 {
619         if ((dungeon[nrow][ncol] & TUNNEL) && is_passable(nrow, ncol)) {
620                 return(1);
621         }
622         return(0);
623 }
624
625 static void
626 turn_passage(short dir, boolean fast)
627 {
628         short crow = rogue.row, ccol = rogue.col, turns = 0;
629         short ndir = 0;
630
631         if ((dir != 'h') && can_turn(crow, ccol + 1)) {
632                 turns++;
633                 ndir = 'l';
634         }
635         if ((dir != 'l') && can_turn(crow, ccol - 1)) {
636                 turns++;
637                 ndir = 'h';
638         }
639         if ((dir != 'k') && can_turn(crow + 1, ccol)) {
640                 turns++;
641                 ndir = 'j';
642         }
643         if ((dir != 'j') && can_turn(crow - 1, ccol)) {
644                 turns++;
645                 ndir = 'k';
646         }
647         if (turns == 1) {
648                 multiple_move_rogue(ndir - (fast ? 32 : 96));
649         }
650 }