src/object-broken.c

   1 #include "angband.h"
   2 #include "spells.h"
   3 #include "objectkind.h"
   4 #include "snipe.h"
   5
   6 /*!
   7 * @brief アイテムが酸で破損するかどうかを判定する
   8 * @param o_ptr アイテムの情報参照ポインタ
   9 * @return 破損するならばTRUEを返す
  10 * Note that amulets, rods, and high-level spell books are immune
  11 * to "p_ptr->inventory_list damage" of any kind.  Also sling ammo and shovels.
  12 * Does a given class of objects (usually) hate acid?
  13 * Note that acid can either melt or corrode something.
  14 */
  15 bool hates_acid(object_type *o_ptr)
  16 {
  17         /* Analyze the type */
  18         switch (o_ptr->tval)
  19         {
  20                 /* Wearable items */
  21         case TV_ARROW:
  22         case TV_BOLT:
  23         case TV_BOW:
  24         case TV_SWORD:
  25         case TV_HAFTED:
  26         case TV_POLEARM:
  27         case TV_HELM:
  28         case TV_CROWN:
  29         case TV_SHIELD:
  30         case TV_BOOTS:
  31         case TV_GLOVES:
  32         case TV_CLOAK:
  33         case TV_SOFT_ARMOR:
  34         case TV_HARD_ARMOR:
  35         case TV_DRAG_ARMOR:
  36         {
  37                 return (TRUE);
  38         }
  39
  40         /* Staffs/Scrolls are wood/paper */
  41         case TV_STAFF:
  42         case TV_SCROLL:
  43         {
  44                 return (TRUE);
  45         }
  46
  47         /* Ouch */
  48         case TV_CHEST:
  49         {
  50                 return (TRUE);
  51         }
  52
  53         /* Junk is useless */
  54         case TV_SKELETON:
  55         case TV_BOTTLE:
  56         case TV_JUNK:
  57         {
  58                 return (TRUE);
  59         }
  60         }
  61
  62         return (FALSE);
  63 }
  64
  65
  66 /*!
  67 * @brief アイテムが電撃で破損するかどうかを判定する /
  68 * Does a given object (usually) hate electricity?
  69 * @param o_ptr アイテムの情報参照ポインタ
  70 * @return 破損するならばTRUEを返す
  71 */
  72 bool hates_elec(object_type *o_ptr)
  73 {
  74         switch (o_ptr->tval)
  75         {
  76         case TV_RING:
  77         case TV_WAND:
  78         {
  79                 return (TRUE);
  80         }
  81         }
  82
  83         return (FALSE);
  84 }
  85
  86
  87 /*!
  88 * @brief アイテムが火炎で破損するかどうかを判定する /
  89 * Does a given object (usually) hate fire?
  90 * @param o_ptr アイテムの情報参照ポインタ
  91 * @return 破損するならばTRUEを返す
  92 * @details
  93 * Hafted/Polearm weapons have wooden shafts.
  94 * Arrows/Bows are mostly wooden.
  95 */
  96 bool hates_fire(object_type *o_ptr)
  97 {
  98         /* Analyze the type */
  99         switch (o_ptr->tval)
 100         {
 101                 /* Wearable */
 102         case TV_LITE:
 103         case TV_ARROW:
 104         case TV_BOW:
 105         case TV_HAFTED:
 106         case TV_POLEARM:
 107         case TV_BOOTS:
 108         case TV_GLOVES:
 109         case TV_CLOAK:
 110         case TV_SOFT_ARMOR:
 111         {
 112                 return (TRUE);
 113         }
 114
 115         /* Books */
 116         case TV_LIFE_BOOK:
 117         case TV_SORCERY_BOOK:
 118         case TV_NATURE_BOOK:
 119         case TV_CHAOS_BOOK:
 120         case TV_DEATH_BOOK:
 121         case TV_TRUMP_BOOK:
 122         case TV_ARCANE_BOOK:
 123         case TV_CRAFT_BOOK:
 124         case TV_DAEMON_BOOK:
 125         case TV_CRUSADE_BOOK:
 126         case TV_MUSIC_BOOK:
 127         case TV_HISSATSU_BOOK:
 128         case TV_HEX_BOOK:
 129         {
 130                 return (TRUE);
 131         }
 132
 133         /* Chests */
 134         case TV_CHEST:
 135         {
 136                 return (TRUE);
 137         }
 138
 139         /* Staffs/Scrolls burn */
 140         case TV_STAFF:
 141         case TV_SCROLL:
 142         {
 143                 return (TRUE);
 144         }
 145         }
 146
 147         return (FALSE);
 148 }
 149
 150
 151 /*!
 152 * @brief アイテムが冷気で破損するかどうかを判定する /
 153 * Does a given object (usually) hate cold?
 154 * @param o_ptr アイテムの情報参照ポインタ
 155 * @return 破損するならばTRUEを返す
 156 */
 157 bool hates_cold(object_type *o_ptr)
 158 {
 159         switch (o_ptr->tval)
 160         {
 161         case TV_POTION:
 162         case TV_FLASK:
 163         case TV_BOTTLE:
 164         {
 165                 return (TRUE);
 166         }
 167         }
 168
 169         return (FALSE);
 170 }
 171
 172
 173
 174 /*!
 175 * @brief アイテムが酸で破損するかどうかを判定する(メインルーチン) /
 176 * Melt something
 177 * @param o_ptr アイテムの情報参照ポインタ
 178 * @return 破損するならばTRUEを返す
 179 * @todo 統合を検討
 180 */
 181 int set_acid_destroy(object_type *o_ptr)
 182 {
 183         BIT_FLAGS flgs[TR_FLAG_SIZE];
 184         if (!hates_acid(o_ptr)) return (FALSE);
 185         object_flags(o_ptr, flgs);
 186         if (have_flag(flgs, TR_IGNORE_ACID)) return (FALSE);
 187         return (TRUE);
 188 }
 189
 190
 191 /*!
 192 * @brief アイテムが電撃で破損するかどうかを判定する(メインルーチン) /
 193 * Electrical damage
 194 * @param o_ptr アイテムの情報参照ポインタ
 195 * @return 破損するならばTRUEを返す
 196 * @todo 統合を検討
 197 */
 198 int set_elec_destroy(object_type *o_ptr)
 199 {
 200         BIT_FLAGS flgs[TR_FLAG_SIZE];
 201         if (!hates_elec(o_ptr)) return (FALSE);
 202         object_flags(o_ptr, flgs);
 203         if (have_flag(flgs, TR_IGNORE_ELEC)) return (FALSE);
 204         return (TRUE);
 205 }
 206
 207
 208 /*!
 209 * @brief アイテムが火炎で破損するかどうかを判定する(メインルーチン) /
 210 * Burn something
 211 * @param o_ptr アイテムの情報参照ポインタ
 212 * @return 破損するならばTRUEを返す
 213 * @todo 統合を検討
 214 */
 215 int set_fire_destroy(object_type *o_ptr)
 216 {
 217         BIT_FLAGS flgs[TR_FLAG_SIZE];
 218         if (!hates_fire(o_ptr)) return (FALSE);
 219         object_flags(o_ptr, flgs);
 220         if (have_flag(flgs, TR_IGNORE_FIRE)) return (FALSE);
 221         return (TRUE);
 222 }
 223
 224
 225 /*!
 226 * @brief アイテムが冷気で破損するかどうかを判定する(メインルーチン) /
 227 * Freeze things
 228 * @param o_ptr アイテムの情報参照ポインタ
 229 * @return 破損するならばTRUEを返す
 230 * @todo 統合を検討
 231 */
 232 int set_cold_destroy(object_type *o_ptr)
 233 {
 234         BIT_FLAGS flgs[TR_FLAG_SIZE];
 235         if (!hates_cold(o_ptr)) return (FALSE);
 236         object_flags(o_ptr, flgs);
 237         if (have_flag(flgs, TR_IGNORE_COLD)) return (FALSE);
 238         return (TRUE);
 239 }
 240
 241 /*!
 242  * @brief 薬の破損効果処理 /
 243  * Potions "smash open" and cause an area effect when
 244  * @param who 薬破損の主体ID(プレイヤー所持アイテムが壊れた場合0、床上のアイテムの場合モンスターID)
 245  * @param y 破壊時のY座標
 246  * @param x 破壊時のX座標
 247  * @param k_idx 破損した薬のアイテムID
 248  * @return 薬を浴びたモンスターが起こるならばTRUEを返す
 249  * @details
 250  * <pre>
 251  * (1) they are shattered while in the player's p_ptr->inventory_list,
 252  * due to cold (etc) attacks;
 253  * (2) they are thrown at a monster, or obstacle;
 254  * (3) they are shattered by a "cold ball" or other such spell
 255  * while lying on the floor.
 256  *
 257  * Arguments:
 258  *    who   ---  who caused the potion to shatter (0=player)
 259  *          potions that smash on the floor are assumed to
 260  *          be caused by no-one (who = 1), as are those that
 261  *          shatter inside the player p_ptr->inventory_list.
 262  *          (Not anymore -- I changed this; TY)
 263  *    y, x  --- coordinates of the potion (or player if
 264  *          the potion was in her p_ptr->inventory_list);
 265  *    o_ptr --- pointer to the potion object.
 266  * </pre>
 267  */
 268 bool potion_smash_effect(MONSTER_IDX who, POSITION y, POSITION x, KIND_OBJECT_IDX k_idx)
 269 {
 270         int     radius = 2;
 271         int     dt = 0;
 272         int     dam = 0;
 273         bool    angry = FALSE;
 274
 275         object_kind *k_ptr = &k_info[k_idx];
 276
 277         switch (k_ptr->sval)
 278         {
 279         case SV_POTION_SALT_WATER:
 280         case SV_POTION_SLIME_MOLD:
 281         case SV_POTION_LOSE_MEMORIES:
 282         case SV_POTION_DEC_STR:
 283         case SV_POTION_DEC_INT:
 284         case SV_POTION_DEC_WIS:
 285         case SV_POTION_DEC_DEX:
 286         case SV_POTION_DEC_CON:
 287         case SV_POTION_DEC_CHR:
 288         case SV_POTION_WATER:   /* perhaps a 'water' attack? */
 289         case SV_POTION_APPLE_JUICE:
 290                 return TRUE;
 291
 292         case SV_POTION_INFRAVISION:
 293         case SV_POTION_DETECT_INVIS:
 294         case SV_POTION_SLOW_POISON:
 295         case SV_POTION_CURE_POISON:
 296         case SV_POTION_BOLDNESS:
 297         case SV_POTION_RESIST_HEAT:
 298         case SV_POTION_RESIST_COLD:
 299         case SV_POTION_HEROISM:
 300         case SV_POTION_BESERK_STRENGTH:
 301         case SV_POTION_RES_STR:
 302         case SV_POTION_RES_INT:
 303         case SV_POTION_RES_WIS:
 304         case SV_POTION_RES_DEX:
 305         case SV_POTION_RES_CON:
 306         case SV_POTION_RES_CHR:
 307         case SV_POTION_INC_STR:
 308         case SV_POTION_INC_INT:
 309         case SV_POTION_INC_WIS:
 310         case SV_POTION_INC_DEX:
 311         case SV_POTION_INC_CON:
 312         case SV_POTION_INC_CHR:
 313         case SV_POTION_AUGMENTATION:
 314         case SV_POTION_ENLIGHTENMENT:
 315         case SV_POTION_STAR_ENLIGHTENMENT:
 316         case SV_POTION_SELF_KNOWLEDGE:
 317         case SV_POTION_EXPERIENCE:
 318         case SV_POTION_RESISTANCE:
 319         case SV_POTION_INVULNERABILITY:
 320         case SV_POTION_NEW_LIFE:
 321                 /* All of the above potions have no effect when shattered */
 322                 return FALSE;
 323         case SV_POTION_SLOWNESS:
 324                 dt = GF_OLD_SLOW;
 325                 dam = 5;
 326                 angry = TRUE;
 327                 break;
 328         case SV_POTION_POISON:
 329                 dt = GF_POIS;
 330                 dam = 3;
 331                 angry = TRUE;
 332                 break;
 333         case SV_POTION_BLINDNESS:
 334                 dt = GF_DARK;
 335                 angry = TRUE;
 336                 break;
 337         case SV_POTION_BOOZE: /* Booze */
 338                 dt = GF_OLD_CONF;
 339                 angry = TRUE;
 340                 break;
 341         case SV_POTION_SLEEP:
 342                 dt = GF_OLD_SLEEP;
 343                 angry = TRUE;
 344                 break;
 345         case SV_POTION_RUINATION:
 346         case SV_POTION_DETONATIONS:
 347                 dt = GF_SHARDS;
 348                 dam = damroll(25, 25);
 349                 angry = TRUE;
 350                 break;
 351         case SV_POTION_DEATH:
 352                 dt = GF_DEATH_RAY;    /* !! */
 353                 dam = k_ptr->level * 10;
 354                 angry = TRUE;
 355                 radius = 1;
 356                 break;
 357         case SV_POTION_SPEED:
 358                 dt = GF_OLD_SPEED;
 359                 break;
 360         case SV_POTION_CURE_LIGHT:
 361                 dt = GF_OLD_HEAL;
 362                 dam = damroll(2, 3);
 363                 break;
 364         case SV_POTION_CURE_SERIOUS:
 365                 dt = GF_OLD_HEAL;
 366                 dam = damroll(4, 3);
 367                 break;
 368         case SV_POTION_CURE_CRITICAL:
 369         case SV_POTION_CURING:
 370                 dt = GF_OLD_HEAL;
 371                 dam = damroll(6, 3);
 372                 break;
 373         case SV_POTION_HEALING:
 374                 dt = GF_OLD_HEAL;
 375                 dam = damroll(10, 10);
 376                 break;
 377         case SV_POTION_RESTORE_EXP:
 378                 dt = GF_STAR_HEAL;
 379                 dam = 0;
 380                 radius = 1;
 381                 break;
 382         case SV_POTION_LIFE:
 383                 dt = GF_STAR_HEAL;
 384                 dam = damroll(50, 50);
 385                 radius = 1;
 386                 break;
 387         case SV_POTION_STAR_HEALING:
 388                 dt = GF_OLD_HEAL;
 389                 dam = damroll(50, 50);
 390                 radius = 1;
 391                 break;
 392         case SV_POTION_RESTORE_MANA:   /* MANA */
 393                 dt = GF_MANA;
 394                 dam = damroll(10, 10);
 395                 radius = 1;
 396                 break;
 397         default:
 398                 /* Do nothing */;
 399         }
 400
 401         (void)project(p_ptr, who, radius, y, x, dam, dt, (PROJECT_JUMP | PROJECT_ITEM | PROJECT_KILL), -1);
 402
 403         /* XXX  those potions that explode need to become "known" */
 404         return angry;
 405 }
 406
 407 /*!
 408  * @brief 矢弾を射撃した場合の破損確率を返す /
 409  * Determines the odds of an object breaking when thrown at a monster
 410  * @param o_ptr 矢弾のオブジェクト構造体参照ポインタ
 411  * @return 破損確率(%)
 412  * @details
 413  * Note that artifacts never break, see the "drop_near()" function.
 414  */
 415 PERCENTAGE breakage_chance(object_type *o_ptr, bool has_archer_bonus, SPELL_IDX snipe_type)
 416 {
 417         PERCENTAGE archer_bonus = (has_archer_bonus ? (PERCENTAGE)(p_ptr->lev - 1) / 7 + 4 : 0);
 418
 419         /* Examine the snipe type */
 420         if (snipe_type)
 421         {
 422                 if (snipe_type == SP_KILL_WALL) return (100);
 423                 if (snipe_type == SP_EXPLODE) return (100);
 424                 if (snipe_type == SP_PIERCE) return (100);
 425                 if (snipe_type == SP_FINAL) return (100);
 426                 if (snipe_type == SP_NEEDLE) return (100);
 427                 if (snipe_type == SP_EVILNESS) return (40);
 428                 if (snipe_type == SP_HOLYNESS) return (40);
 429         }
 430
 431         /* Examine the item type */
 432         switch (o_ptr->tval)
 433         {
 434                 /* Always break */
 435         case TV_FLASK:
 436         case TV_POTION:
 437         case TV_BOTTLE:
 438         case TV_FOOD:
 439         case TV_JUNK:
 440                 return (100);
 441
 442                 /* Often break */
 443         case TV_LITE:
 444         case TV_SCROLL:
 445         case TV_SKELETON:
 446                 return (50);
 447
 448                 /* Sometimes break */
 449         case TV_WAND:
 450         case TV_SPIKE:
 451                 return (25);
 452         case TV_ARROW:
 453                 return (20 - archer_bonus * 2);
 454
 455                 /* Rarely break */
 456         case TV_SHOT:
 457         case TV_BOLT:
 458                 return (10 - archer_bonus);
 459         default:
 460                 return (10);
 461         }
 462 }