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