rogue/hit.c

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