rogue/hit.c

   1 /*      $NetBSD: hit.c,v 1.4 1997/10/12 11:45:05 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[] = "@(#)hit.c       8.1 (Berkeley) 5/31/93";
  43 #else
  44 __RCSID("$NetBSD: hit.c,v 1.4 1997/10/12 11:45:05 lukem Exp $");
  45 #endif
  46 #endif /* not lint */
  47
  48 /*
  49  * hit.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 object *fight_monster = 0;
  63 char hit_message[80] = "";
  64
  65 void
  66 mon_hit(monster)
  67         object *monster;
  68 {
  69         short damage, hit_chance;
  70         char *mn;
  71         float minus;
  72
  73         if (fight_monster && (monster != fight_monster)) {
  74                 fight_monster = 0;
  75         }
  76         monster->trow = NO_ROOM;
  77         if (cur_level >= (AMULET_LEVEL * 2)) {
  78                 hit_chance = 100;
  79         } else {
  80                 hit_chance = monster->m_hit_chance;
  81                 hit_chance -= (((2 * rogue.exp) + (2 * ring_exp)) - r_rings);
  82         }
  83         if (wizard) {
  84                 hit_chance /= 2;
  85         }
  86         if (!fight_monster) {
  87                 interrupted = 1;
  88         }
  89         mn = mon_name(monster);
  90
  91         if (!rand_percent(hit_chance)) {
  92                 if (!fight_monster) {
  93                         sprintf(hit_message + strlen(hit_message),
  94                             "the %s misses", mn);
  95                         message(hit_message, 1);
  96                         hit_message[0] = 0;
  97                 }
  98                 return;
  99         }
 100         if (!fight_monster) {
 101                 sprintf(hit_message + strlen(hit_message), "the %s hit", mn);
 102                 message(hit_message, 1);
 103                 hit_message[0] = 0;
 104         }
 105         if (!(monster->m_flags & STATIONARY)) {
 106                 damage = get_damage(monster->m_damage, 1);
 107                 if (cur_level >= (AMULET_LEVEL * 2)) {
 108                         minus = (float) ((AMULET_LEVEL * 2) - cur_level);
 109                 } else {
 110                         minus = (float) get_armor_class(rogue.armor) * 3.00;
 111                         minus = minus/100.00 * (float) damage;
 112                 }
 113                 damage -= (short) minus;
 114         } else {
 115                 damage = monster->stationary_damage++;
 116         }
 117         if (wizard) {
 118                 damage /= 3;
 119         }
 120         if (damage > 0) {
 121                 rogue_damage(damage, monster, 0);
 122         }
 123         if (monster->m_flags & SPECIAL_HIT) {
 124                 special_hit(monster);
 125         }
 126 }
 127
 128 void
 129 rogue_hit(monster, force_hit)
 130         object *monster;
 131         boolean force_hit;
 132 {
 133         short damage, hit_chance;
 134
 135         if (monster) {
 136                 if (check_imitator(monster)) {
 137                         return;
 138                 }
 139                 hit_chance = force_hit ? 100 : get_hit_chance(rogue.weapon);
 140
 141                 if (wizard) {
 142                         hit_chance *= 2;
 143                 }
 144                 if (!rand_percent(hit_chance)) {
 145                         if (!fight_monster) {
 146                                 (void) strcpy(hit_message, "you miss  ");
 147                         }
 148                         goto RET;
 149                 }
 150                 damage = get_weapon_damage(rogue.weapon);
 151                 if (wizard) {
 152                         damage *= 3;
 153                 }
 154                 if (con_mon) {
 155                         s_con_mon(monster);
 156                 }
 157                 if (mon_damage(monster, damage)) {      /* still alive? */
 158                         if (!fight_monster) {
 159                                 (void) strcpy(hit_message, "you hit  ");
 160                         }
 161                 }
 162 RET:    check_gold_seeker(monster);
 163                 wake_up(monster);
 164         }
 165 }
 166
 167 void
 168 rogue_damage(d, monster, other)
 169         short d;
 170         object *monster;
 171         short other;
 172 {
 173         if (d >= rogue.hp_current) {
 174                 rogue.hp_current = 0;
 175                 print_stats(STAT_HP);
 176                 killed_by(monster, other);
 177         }
 178         if (d > 0) {
 179                 rogue.hp_current -= d;
 180                 print_stats(STAT_HP);
 181         }
 182 }
 183
 184 int
 185 get_damage(ds, r)
 186         char *ds;
 187         boolean r;
 188 {
 189         int i = 0, j, n, d, total = 0;
 190
 191         while (ds[i]) {
 192                 n = get_number(ds+i);
 193                 while (ds[i++] != 'd') ;
 194                 d = get_number(ds+i);
 195                 while ((ds[i] != '/') && ds[i]) i++;
 196
 197                 for (j = 0; j < n; j++) {
 198                         if (r) {
 199                                 total += get_rand(1, d);
 200                         } else {
 201                                 total += d;
 202                         }
 203                 }
 204                 if (ds[i] == '/') {
 205                         i++;
 206                 }
 207         }
 208         return(total);
 209 }
 210
 211 int
 212 get_w_damage(obj)
 213         object *obj;
 214 {
 215         char new_damage[12];
 216         int to_hit, damage;
 217         int i = 0;
 218
 219         if ((!obj) || (obj->what_is != WEAPON)) {
 220                 return(-1);
 221         }
 222         to_hit = get_number(obj->damage) + obj->hit_enchant;
 223         while (obj->damage[i++] != 'd') ;
 224         damage = get_number(obj->damage + i) + obj->d_enchant;
 225
 226         sprintf(new_damage, "%dd%d", to_hit, damage);
 227
 228         return(get_damage(new_damage, 1));
 229 }
 230
 231 int
 232 get_number(s)
 233         char *s;
 234 {
 235         int i = 0;
 236         int total = 0;
 237
 238         while ((s[i] >= '0') && (s[i] <= '9')) {
 239                 total = (10 * total) + (s[i] - '0');
 240                 i++;
 241         }
 242         return(total);
 243 }
 244
 245 long
 246 lget_number(s)
 247         char *s;
 248 {
 249         short i = 0;
 250         long total = 0;
 251
 252         while ((s[i] >= '0') && (s[i] <= '9')) {
 253                 total = (10 * total) + (s[i] - '0');
 254                 i++;
 255         }
 256         return(total);
 257 }
 258
 259 int
 260 to_hit(obj)
 261         object *obj;
 262 {
 263         if (!obj) {
 264                 return(1);
 265         }
 266         return(get_number(obj->damage) + obj->hit_enchant);
 267 }
 268
 269 int
 270 damage_for_strength()
 271 {
 272         short strength;
 273
 274         strength = rogue.str_current + add_strength;
 275
 276         if (strength <= 6) {
 277                 return(strength-5);
 278         }
 279         if (strength <= 14) {
 280                 return(1);
 281         }
 282         if (strength <= 17) {
 283                 return(3);
 284         }
 285         if (strength <= 18) {
 286                 return(4);
 287         }
 288         if (strength <= 20) {
 289                 return(5);
 290         }
 291         if (strength <= 21) {
 292                 return(6);
 293         }
 294         if (strength <= 30) {
 295                 return(7);
 296         }
 297         return(8);
 298 }
 299
 300 int
 301 mon_damage(monster, damage)
 302         object *monster;
 303         short damage;
 304 {
 305         char *mn;
 306         short row, col;
 307
 308         monster->hp_to_kill -= damage;
 309
 310         if (monster->hp_to_kill <= 0) {
 311                 row = monster->row;
 312                 col = monster->col;
 313                 dungeon[row][col] &= ~MONSTER;
 314                 mvaddch(row, col, (int) get_dungeon_char(row, col));
 315
 316                 fight_monster = 0;
 317                 cough_up(monster);
 318                 mn = mon_name(monster);
 319                 sprintf(hit_message+strlen(hit_message), "defeated the %s", mn);
 320                 message(hit_message, 1);
 321                 hit_message[0] = 0;
 322                 add_exp(monster->kill_exp, 1);
 323                 take_from_pack(monster, &level_monsters);
 324
 325                 if (monster->m_flags & HOLDS) {
 326                         being_held = 0;
 327                 }
 328                 free_object(monster);
 329                 return(0);
 330         }
 331         return(1);
 332 }
 333
 334 void
 335 fight(to_the_death)
 336         boolean to_the_death;
 337 {
 338         short ch, c, d;
 339         short row, col;
 340         boolean first_miss = 1;
 341         short possible_damage;
 342         object *monster;
 343
 344         ch = 0;
 345         while (!is_direction(ch = rgetchar(), &d)) {
 346                 sound_bell();
 347                 if (first_miss) {
 348                         message("direction?", 0);
 349                         first_miss = 0;
 350                 }
 351         }
 352         check_message();
 353         if (ch == CANCEL) {
 354                 return;
 355         }
 356         row = rogue.row; col = rogue.col;
 357         get_dir_rc(d, &row, &col, 0);
 358
 359         c = mvinch(row, col);
 360         if (((c < 'A') || (c > 'Z')) ||
 361                 (!can_move(rogue.row, rogue.col, row, col))) {
 362                 message("I see no monster there", 0);
 363                 return;
 364         }
 365         if (!(fight_monster = object_at(&level_monsters, row, col))) {
 366                 return;
 367         }
 368         if (!(fight_monster->m_flags & STATIONARY)) {
 369                 possible_damage = ((get_damage(fight_monster->m_damage, 0) * 2) / 3);
 370         } else {
 371                 possible_damage = fight_monster->stationary_damage - 1;
 372         }
 373         while (fight_monster) {
 374                 (void) one_move_rogue(ch, 0);
 375                 if (((!to_the_death) && (rogue.hp_current <= possible_damage)) ||
 376                         interrupted || (!(dungeon[row][col] & MONSTER))) {
 377                         fight_monster = 0;
 378                 } else {
 379                         monster = object_at(&level_monsters, row, col);
 380                         if (monster != fight_monster) {
 381                                 fight_monster = 0;
 382                         }
 383                 }
 384         }
 385 }
 386
 387 void
 388 get_dir_rc(dir, row, col, allow_off_screen)
 389         short dir;
 390         short *row, *col;
 391         short allow_off_screen;
 392 {
 393         switch(dir) {
 394         case LEFT:
 395                 if (allow_off_screen || (*col > 0)) {
 396                         (*col)--;
 397                 }
 398                 break;
 399         case DOWN:
 400                 if (allow_off_screen || (*row < (DROWS-2))) {
 401                         (*row)++;
 402                 }
 403                 break;
 404         case UPWARD:
 405                 if (allow_off_screen || (*row > MIN_ROW)) {
 406                         (*row)--;
 407                 }
 408                 break;
 409         case RIGHT:
 410                 if (allow_off_screen || (*col < (DCOLS-1))) {
 411                         (*col)++;
 412                 }
 413                 break;
 414         case UPLEFT:
 415                 if (allow_off_screen || ((*row > MIN_ROW) && (*col > 0))) {
 416                         (*row)--;
 417                         (*col)--;
 418                 }
 419                 break;
 420         case UPRIGHT:
 421                 if (allow_off_screen || ((*row > MIN_ROW) && (*col < (DCOLS-1)))) {
 422                         (*row)--;
 423                         (*col)++;
 424                 }
 425                 break;
 426         case DOWNRIGHT:
 427                 if (allow_off_screen || ((*row < (DROWS-2)) && (*col < (DCOLS-1)))) {
 428                         (*row)++;
 429                         (*col)++;
 430                 }
 431                 break;
 432         case DOWNLEFT:
 433                 if (allow_off_screen || ((*row < (DROWS-2)) && (*col > 0))) {
 434                         (*row)++;
 435                         (*col)--;
 436                 }
 437                 break;
 438         }
 439 }
 440
 441 int
 442 get_hit_chance(weapon)
 443         object *weapon;
 444 {
 445         short hit_chance;
 446
 447         hit_chance = 40;
 448         hit_chance += 3 * to_hit(weapon);
 449         hit_chance += (((2 * rogue.exp) + (2 * ring_exp)) - r_rings);
 450         return(hit_chance);
 451 }
 452
 453 int
 454 get_weapon_damage(weapon)
 455         object *weapon;
 456 {
 457         short damage;
 458
 459         damage = get_w_damage(weapon);
 460         damage += damage_for_strength();
 461         damage += ((((rogue.exp + ring_exp) - r_rings) + 1) / 2);
 462         return(damage);
 463 }
 464
 465 void
 466 s_con_mon(monster)
 467         object *monster;
 468 {
 469         if (con_mon) {
 470                 monster->m_flags |= CONFUSED;
 471                 monster->moves_confused += get_rand(12, 22);
 472                 message("the monster appears confused", 0);
 473                 con_mon = 0;
 474         }
 475 }