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