src/market/store-util.c

   1 #include "angband.h"
   2 #include "market/store-util.h"
   3 #include "object-hook.h"
   4 #include "objectkind.h"
   5
   6 int cur_store_num = 0;
   7 store_type *st_ptr = NULL;
   8
   9 /*!
  10  * @brief 店舗のオブジェクト数を増やす /
  11  * Add the item "o_ptr" to a real stores inventory.
  12  * @param item 増やしたいアイテムのID
  13  * @param num 増やしたい数
  14  * @return なし
  15  * @details
  16  * <pre>
  17  * Increase, by a given amount, the number of a certain item
  18  * in a certain store.  This can result in zero items.
  19  * </pre>
  20  * @todo numは本来ITEM_NUMBER型にしたい。
  21  */
  22 void store_item_increase(INVENTORY_IDX item, int num)
  23 {
  24         object_type *o_ptr;
  25         o_ptr = &st_ptr->stock[item];
  26         int cnt = o_ptr->number + num;
  27         if (cnt > 255) cnt = 255;
  28         else if (cnt < 0) cnt = 0;
  29
  30         num = cnt - o_ptr->number;
  31         o_ptr->number += (ITEM_NUMBER)num;
  32 }
  33
  34
  35 /*!
  36  * @brief 店舗のオブジェクト数を削除する /
  37  * Remove a slot if it is empty
  38  * @param item 削除したいアイテムのID
  39  * @return なし
  40  */
  41 void store_item_optimize(INVENTORY_IDX item)
  42 {
  43         object_type *o_ptr;
  44         o_ptr = &st_ptr->stock[item];
  45         if (!o_ptr->k_idx) return;
  46         if (o_ptr->number) return;
  47
  48         st_ptr->stock_num--;
  49         for (int j = item; j < st_ptr->stock_num; j++)
  50         {
  51                 st_ptr->stock[j] = st_ptr->stock[j + 1];
  52         }
  53
  54         object_wipe(&st_ptr->stock[st_ptr->stock_num]);
  55 }
  56
  57
  58 /*!
  59  * @brief 店舗の品揃え変化のためにアイテムを削除する /
  60  * Attempt to delete (some of) a random item from the store
  61  * @return なし
  62  * @details
  63  * <pre>
  64  * Hack -- we attempt to "maintain" piles of items when possible.
  65  * </pre>
  66  */
  67 void store_delete(void)
  68 {
  69         INVENTORY_IDX what = (INVENTORY_IDX)randint0(st_ptr->stock_num);
  70         int num = st_ptr->stock[what].number;
  71         if (randint0(100) < 50) num = (num + 1) / 2;
  72         if (randint0(100) < 50) num = 1;
  73         if ((st_ptr->stock[what].tval == TV_ROD) || (st_ptr->stock[what].tval == TV_WAND))
  74         {
  75                 st_ptr->stock[what].pval -= num * st_ptr->stock[what].pval / st_ptr->stock[what].number;
  76         }
  77
  78         store_item_increase(what, -num);
  79         store_item_optimize(what);
  80 }
  81
  82
  83 /*!
  84  * @brief 安価な消耗品の販売数を増やし、低確率で割引にする /
  85  * Certain "cheap" objects should be created in "piles"
  86  * @param o_ptr 店舗に並べるオブジェクト構造体の参照ポインタ
  87  * @return なし
  88  * @details
  89  * <pre>
  90  * Some objects can be sold at a "discount" (in small piles)
  91  * </pre>
  92  */
  93 static void mass_produce(object_type *o_ptr)
  94 {
  95         int size = 1;
  96         PRICE cost = object_value(o_ptr);
  97         switch (o_ptr->tval)
  98         {
  99         case TV_FOOD:
 100         case TV_FLASK:
 101         case TV_LITE:
 102         {
 103                 if (cost <= 5L) size += damroll(3, 5);
 104                 if (cost <= 20L) size += damroll(3, 5);
 105                 if (cost <= 50L) size += damroll(2, 2);
 106                 break;
 107         }
 108         case TV_POTION:
 109         case TV_SCROLL:
 110         {
 111                 if (cost <= 60L) size += damroll(3, 5);
 112                 if (cost <= 240L) size += damroll(1, 5);
 113                 if (o_ptr->sval == SV_SCROLL_STAR_IDENTIFY) size += damroll(3, 5);
 114                 if (o_ptr->sval == SV_SCROLL_STAR_REMOVE_CURSE) size += damroll(1, 4);
 115                 break;
 116         }
 117         case TV_LIFE_BOOK:
 118         case TV_SORCERY_BOOK:
 119         case TV_NATURE_BOOK:
 120         case TV_CHAOS_BOOK:
 121         case TV_DEATH_BOOK:
 122         case TV_TRUMP_BOOK:
 123         case TV_ARCANE_BOOK:
 124         case TV_CRAFT_BOOK:
 125         case TV_DAEMON_BOOK:
 126         case TV_CRUSADE_BOOK:
 127         case TV_MUSIC_BOOK:
 128         case TV_HISSATSU_BOOK:
 129         case TV_HEX_BOOK:
 130         {
 131                 if (cost <= 50L) size += damroll(2, 3);
 132                 if (cost <= 500L) size += damroll(1, 3);
 133                 break;
 134         }
 135         case TV_SOFT_ARMOR:
 136         case TV_HARD_ARMOR:
 137         case TV_SHIELD:
 138         case TV_GLOVES:
 139         case TV_BOOTS:
 140         case TV_CLOAK:
 141         case TV_HELM:
 142         case TV_CROWN:
 143         case TV_SWORD:
 144         case TV_POLEARM:
 145         case TV_HAFTED:
 146         case TV_DIGGING:
 147         case TV_BOW:
 148         {
 149                 if (object_is_artifact(o_ptr)) break;
 150                 if (object_is_ego(o_ptr)) break;
 151                 if (cost <= 10L) size += damroll(3, 5);
 152                 if (cost <= 100L) size += damroll(3, 5);
 153                 break;
 154         }
 155         case TV_SPIKE:
 156         case TV_SHOT:
 157         case TV_ARROW:
 158         case TV_BOLT:
 159         {
 160                 if (cost <= 5L) size += damroll(5, 5);
 161                 if (cost <= 50L) size += damroll(5, 5);
 162                 if (cost <= 500L) size += damroll(5, 5);
 163                 break;
 164         }
 165         case TV_FIGURINE:
 166         {
 167                 if (cost <= 100L) size += damroll(2, 2);
 168                 if (cost <= 1000L) size += damroll(2, 2);
 169                 break;
 170         }
 171         case TV_CAPTURE:
 172         case TV_STATUE:
 173         case TV_CARD:
 174         {
 175                 size = 1;
 176                 break;
 177         }
 178
 179         /*
 180          * Because many rods (and a few wands and staffs) are useful mainly
 181          * in quantity, the Black Market will occasionally have a bunch of
 182          * one kind. -LM-
 183          */
 184         case TV_ROD:
 185         case TV_WAND:
 186         case TV_STAFF:
 187         {
 188                 if ((cur_store_num == STORE_BLACK) && one_in_(3))
 189                 {
 190                         if (cost < 1601L) size += damroll(1, 5);
 191                         else if (cost < 3201L) size += damroll(1, 3);
 192                 }
 193                 break;
 194         }
 195         }
 196
 197         DISCOUNT_RATE discount = 0;
 198         if (cost < 5)
 199         {
 200                 discount = 0;
 201         }
 202         else if (one_in_(25))
 203         {
 204                 discount = 25;
 205         }
 206         else if (one_in_(150))
 207         {
 208                 discount = 50;
 209         }
 210         else if (one_in_(300))
 211         {
 212                 discount = 75;
 213         }
 214         else if (one_in_(500))
 215         {
 216                 discount = 90;
 217         }
 218
 219         if (o_ptr->art_name)
 220         {
 221                 discount = 0;
 222         }
 223
 224         o_ptr->discount = discount;
 225         o_ptr->number = size - (size * discount / 100);
 226         if ((o_ptr->tval == TV_ROD) || (o_ptr->tval == TV_WAND))
 227         {
 228                 o_ptr->pval *= (PARAMETER_VALUE)o_ptr->number;
 229         }
 230 }
 231
 232
 233 /*!
 234  * @brief 店舗の品揃え変化のためにアイテムを追加する /
 235  * Creates a random item and gives it to a store
 236  * @param player_ptr プレーヤーへの参照ポインタ
 237  * @return なし
 238  * @details
 239  * <pre>
 240  * This algorithm needs to be rethought.  A lot.
 241  * Currently, "normal" stores use a pre-built array.
 242  * Note -- the "level" given to "obj_get_num()" is a "favored"
 243  * level, that is, there is a much higher chance of getting
 244  * items with a level approaching that of the given level...
 245  * Should we check for "permission" to have the given item?
 246  * </pre>
 247  */
 248 void store_create(player_type *player_ptr, bool (*black_market_crap)(player_type*, object_type*))
 249 {
 250         if (st_ptr->stock_num >= st_ptr->stock_size) return;
 251
 252         for (int tries = 0; tries < 4; tries++)
 253         {
 254                 OBJECT_IDX i;
 255                 DEPTH level;
 256                 if (cur_store_num == STORE_BLACK)
 257                 {
 258                         /* Pick a level for object/magic */
 259                         level = 25 + randint0(25);
 260
 261                         /* Random item (usually of given level) */
 262                         i = get_obj_num(player_ptr, level, 0x00000000);
 263
 264                         /* Handle failure */
 265                         if (i == 0) continue;
 266                 }
 267                 else
 268                 {
 269                         i = st_ptr->table[randint0(st_ptr->table_num)];
 270                         level = rand_range(1, STORE_OBJ_LEVEL);
 271                 }
 272
 273                 object_type forge;
 274                 object_type *q_ptr;
 275                 q_ptr = &forge;
 276                 object_prep(q_ptr, i);
 277                 apply_magic(player_ptr, q_ptr, level, AM_NO_FIXED_ART);
 278                 if (!store_will_buy(q_ptr)) continue;
 279
 280                 if (q_ptr->tval == TV_LITE)
 281                 {
 282                         if (q_ptr->sval == SV_LITE_TORCH) q_ptr->xtra4 = FUEL_TORCH / 2;
 283                         if (q_ptr->sval == SV_LITE_LANTERN) q_ptr->xtra4 = FUEL_LAMP / 2;
 284                 }
 285
 286                 object_known(q_ptr);
 287                 q_ptr->ident |= IDENT_STORE;
 288                 if (q_ptr->tval == TV_CHEST) continue;
 289
 290                 if (cur_store_num == STORE_BLACK)
 291                 {
 292                         if (black_market_crap(player_ptr, q_ptr)) continue;
 293                         if (object_value(q_ptr) < 10) continue;
 294                 }
 295                 else
 296                 {
 297                         if (object_value(q_ptr) <= 0) continue;
 298                 }
 299
 300                 mass_produce(q_ptr);
 301                 (void)store_carry(q_ptr);
 302                 break;
 303         }
 304 }
 305
 306
 307 /*!
 308  * @brief オブジェクトが祝福されているかの判定を返す /
 309  * @param o_ptr 判定したいオブジェクト構造体の参照ポインタ
 310  * @return アイテムが祝福されたアイテムならばTRUEを返す
 311  */
 312 static bool is_blessed_item(object_type *o_ptr)
 313 {
 314         BIT_FLAGS flgs[TR_FLAG_SIZE];
 315         object_flags(o_ptr, flgs);
 316         if (have_flag(flgs, TR_BLESSED)) return TRUE;
 317         else return FALSE;
 318 }
 319
 320
 321 /*!
 322  * @brief オブジェクトが所定の店舗で引き取れるかどうかを返す /
 323  * Determine if the current store will purchase the given item
 324  * @param o_ptr 判定したいオブジェクト構造体の参照ポインタ
 325  * @return アイテムが買い取れるならばTRUEを返す
 326  * @note
 327  * Note that a shop-keeper must refuse to buy "worthless" items
 328  */
 329 bool store_will_buy(object_type *o_ptr)
 330 {
 331         if ((cur_store_num == STORE_HOME) || (cur_store_num == STORE_MUSEUM)) return TRUE;
 332         switch (cur_store_num)
 333         {
 334         case STORE_GENERAL:
 335         {
 336                 switch (o_ptr->tval)
 337                 {
 338                 case TV_POTION:
 339                         if (o_ptr->sval != SV_POTION_WATER) return FALSE;
 340
 341                 case TV_WHISTLE:
 342                 case TV_FOOD:
 343                 case TV_LITE:
 344                 case TV_FLASK:
 345                 case TV_SPIKE:
 346                 case TV_SHOT:
 347                 case TV_ARROW:
 348                 case TV_BOLT:
 349                 case TV_DIGGING:
 350                 case TV_CLOAK:
 351                 case TV_BOTTLE:
 352                 case TV_FIGURINE:
 353                 case TV_STATUE:
 354                 case TV_CAPTURE:
 355                 case TV_CARD:
 356                         break;
 357                 default:
 358                         return FALSE;
 359                 }
 360
 361                 break;
 362         }
 363         case STORE_ARMOURY:
 364         {
 365                 switch (o_ptr->tval)
 366                 {
 367                 case TV_BOOTS:
 368                 case TV_GLOVES:
 369                 case TV_CROWN:
 370                 case TV_HELM:
 371                 case TV_SHIELD:
 372                 case TV_CLOAK:
 373                 case TV_SOFT_ARMOR:
 374                 case TV_HARD_ARMOR:
 375                 case TV_DRAG_ARMOR:
 376                         break;
 377                 default:
 378                         return FALSE;
 379                 }
 380
 381                 break;
 382         }
 383         case STORE_WEAPON:
 384         {
 385                 switch (o_ptr->tval)
 386                 {
 387                 case TV_SHOT:
 388                 case TV_BOLT:
 389                 case TV_ARROW:
 390                 case TV_BOW:
 391                 case TV_DIGGING:
 392                 case TV_POLEARM:
 393                 case TV_SWORD:
 394                 case TV_HISSATSU_BOOK:
 395                         break;
 396                 case TV_HAFTED:
 397                 {
 398                         if (o_ptr->sval == SV_WIZSTAFF) return FALSE;
 399                 }
 400                 break;
 401                 default:
 402                         return FALSE;
 403                 }
 404
 405                 break;
 406         }
 407         case STORE_TEMPLE:
 408         {
 409                 switch (o_ptr->tval)
 410                 {
 411                 case TV_LIFE_BOOK:
 412                 case TV_CRUSADE_BOOK:
 413                 case TV_SCROLL:
 414                 case TV_POTION:
 415                 case TV_HAFTED:
 416                 {
 417                         break;
 418                 }
 419                 case TV_FIGURINE:
 420                 case TV_STATUE:
 421                 {
 422                         monster_race *r_ptr = &r_info[o_ptr->pval];
 423                         if (!(r_ptr->flags3 & RF3_EVIL))
 424                         {
 425                                 if (r_ptr->flags3 & RF3_GOOD) break;
 426                                 if (r_ptr->flags3 & RF3_ANIMAL) break;
 427                                 if (my_strchr("?!", r_ptr->d_char)) break;
 428                         }
 429                 }
 430                 case TV_POLEARM:
 431                 case TV_SWORD:
 432                 {
 433                         if (is_blessed_item(o_ptr)) break;
 434                 }
 435                 default:
 436                         return FALSE;
 437                 }
 438
 439                 break;
 440         }
 441         case STORE_ALCHEMIST:
 442         {
 443                 switch (o_ptr->tval)
 444                 {
 445                 case TV_SCROLL:
 446                 case TV_POTION:
 447                         break;
 448                 default:
 449                         return FALSE;
 450                 }
 451
 452                 break;
 453         }
 454         case STORE_MAGIC:
 455         {
 456                 switch (o_ptr->tval)
 457                 {
 458                 case TV_SORCERY_BOOK:
 459                 case TV_NATURE_BOOK:
 460                 case TV_CHAOS_BOOK:
 461                 case TV_DEATH_BOOK:
 462                 case TV_TRUMP_BOOK:
 463                 case TV_ARCANE_BOOK:
 464                 case TV_CRAFT_BOOK:
 465                 case TV_DAEMON_BOOK:
 466                 case TV_MUSIC_BOOK:
 467                 case TV_HEX_BOOK:
 468                 case TV_AMULET:
 469                 case TV_RING:
 470                 case TV_STAFF:
 471                 case TV_WAND:
 472                 case TV_ROD:
 473                 case TV_SCROLL:
 474                 case TV_POTION:
 475                 case TV_FIGURINE:
 476                         break;
 477                 case TV_HAFTED:
 478                 {
 479                         if (o_ptr->sval == SV_WIZSTAFF) break;
 480                         else return FALSE;
 481                 }
 482                 default:
 483                         return FALSE;
 484                 }
 485
 486                 break;
 487         }
 488         case STORE_BOOK:
 489         {
 490                 switch (o_ptr->tval)
 491                 {
 492                 case TV_SORCERY_BOOK:
 493                 case TV_NATURE_BOOK:
 494                 case TV_CHAOS_BOOK:
 495                 case TV_DEATH_BOOK:
 496                 case TV_LIFE_BOOK:
 497                 case TV_TRUMP_BOOK:
 498                 case TV_ARCANE_BOOK:
 499                 case TV_CRAFT_BOOK:
 500                 case TV_DAEMON_BOOK:
 501                 case TV_CRUSADE_BOOK:
 502                 case TV_MUSIC_BOOK:
 503                 case TV_HEX_BOOK:
 504                         break;
 505                 default:
 506                         return FALSE;
 507                 }
 508
 509                 break;
 510         }
 511         }
 512
 513         if (object_value(o_ptr) <= 0) return FALSE;
 514         return TRUE;
 515 }
 516
 517
 518 /*!
 519  * @brief 店舗に並べた品を同一品であるかどうか判定する /
 520  * Determine if a store item can "absorb" another item
 521  * @param o_ptr 判定するオブジェクト構造体の参照ポインタ1
 522  * @param j_ptr 判定するオブジェクト構造体の参照ポインタ2
 523  * @return 同一扱いできるならTRUEを返す
 524  * @details
 525  * <pre>
 526  * See "object_similar()" for the same function for the "player"
 527  * </pre>
 528  */
 529 bool store_object_similar(object_type *o_ptr, object_type *j_ptr)
 530 {
 531         if (o_ptr == j_ptr) return 0;
 532         if (o_ptr->k_idx != j_ptr->k_idx) return 0;
 533         if ((o_ptr->pval != j_ptr->pval) && (o_ptr->tval != TV_WAND) && (o_ptr->tval != TV_ROD)) return 0;
 534         if (o_ptr->to_h != j_ptr->to_h) return 0;
 535         if (o_ptr->to_d != j_ptr->to_d) return 0;
 536         if (o_ptr->to_a != j_ptr->to_a) return 0;
 537         if (o_ptr->name2 != j_ptr->name2) return 0;
 538         if (object_is_artifact(o_ptr) || object_is_artifact(j_ptr)) return 0;
 539         for (int i = 0; i < TR_FLAG_SIZE; i++)
 540                 if (o_ptr->art_flags[i] != j_ptr->art_flags[i]) return 0;
 541         if (o_ptr->xtra1 || j_ptr->xtra1) return 0;
 542         if (o_ptr->timeout || j_ptr->timeout) return 0;
 543         if (o_ptr->ac != j_ptr->ac)   return 0;
 544         if (o_ptr->dd != j_ptr->dd)   return 0;
 545         if (o_ptr->ds != j_ptr->ds)   return 0;
 546         if (o_ptr->tval == TV_CHEST) return 0;
 547         if (o_ptr->tval == TV_STATUE) return 0;
 548         if (o_ptr->tval == TV_CAPTURE) return 0;
 549         if (o_ptr->discount != j_ptr->discount) return 0;
 550         return TRUE;
 551 }
 552
 553
 554 /*!
 555  * @brief 店舗に並べた品を重ね合わせできるかどうか判定する /
 556  * Allow a store item to absorb another item
 557  * @param o_ptr 判定するオブジェクト構造体の参照ポインタ1
 558  * @param j_ptr 判定するオブジェクト構造体の参照ポインタ2
 559  * @return 重ね合わせできるならTRUEを返す
 560  * @details
 561  * <pre>
 562  * See "object_similar()" for the same function for the "player"
 563  * </pre>
 564  */
 565 static void store_object_absorb(object_type *o_ptr, object_type *j_ptr)
 566 {
 567         int max_num = (o_ptr->tval == TV_ROD) ?
 568                 MIN(99, MAX_SHORT / k_info[o_ptr->k_idx].pval) : 99;
 569         int total = o_ptr->number + j_ptr->number;
 570         int diff = (total > max_num) ? total - max_num : 0;
 571         o_ptr->number = (total > max_num) ? max_num : total;
 572         if (o_ptr->tval == TV_ROD)
 573         {
 574                 o_ptr->pval += j_ptr->pval * (j_ptr->number - diff) / j_ptr->number;
 575         }
 576
 577         if (o_ptr->tval == TV_WAND)
 578         {
 579                 o_ptr->pval += j_ptr->pval * (j_ptr->number - diff) / j_ptr->number;
 580         }
 581 }
 582
 583
 584 /*!
 585  * @brief 店舗にオブジェクトを加える /
 586  * Add the item "o_ptr" to a real stores inventory.
 587  * @param o_ptr 加えたいオブジェクトの構造体参照ポインタ
 588  * @return 収めた先のID
 589  * @details
 590  * <pre>
 591  * In all cases, return the slot (or -1) where the object was placed
 592  * Note that this is a hacked up version of "inven_carry()".
 593  * Also note that it may not correctly "adapt" to "knowledge" bacoming
 594  * known, the player may have to pick stuff up and drop it again.
 595  * </pre>
 596  */
 597 int store_carry(object_type *o_ptr)
 598 {
 599         PRICE value = object_value(o_ptr);
 600         if (value <= 0) return -1;
 601         o_ptr->ident |= IDENT_FULL_KNOWN;
 602         o_ptr->inscription = 0;
 603         o_ptr->feeling = FEEL_NONE;
 604         int slot;
 605         for (slot = 0; slot < st_ptr->stock_num; slot++)
 606         {
 607                 object_type *j_ptr;
 608                 j_ptr = &st_ptr->stock[slot];
 609                 if (store_object_similar(j_ptr, o_ptr))
 610                 {
 611                         store_object_absorb(j_ptr, o_ptr);
 612                         return slot;
 613                 }
 614         }
 615
 616         if (st_ptr->stock_num >= st_ptr->stock_size) return -1;
 617
 618         for (slot = 0; slot < st_ptr->stock_num; slot++)
 619         {
 620                 object_type *j_ptr;
 621                 j_ptr = &st_ptr->stock[slot];
 622                 if (o_ptr->tval > j_ptr->tval) break;
 623                 if (o_ptr->tval < j_ptr->tval) continue;
 624                 if (o_ptr->sval < j_ptr->sval) break;
 625                 if (o_ptr->sval > j_ptr->sval) continue;
 626                 if (o_ptr->tval == TV_ROD)
 627                 {
 628                         if (o_ptr->pval < j_ptr->pval) break;
 629                         if (o_ptr->pval > j_ptr->pval) continue;
 630                 }
 631
 632                 PRICE j_value = object_value(j_ptr);
 633                 if (value > j_value) break;
 634                 if (value < j_value) continue;
 635         }
 636
 637         for (int i = st_ptr->stock_num; i > slot; i--)
 638         {
 639                 st_ptr->stock[i] = st_ptr->stock[i - 1];
 640         }
 641
 642         st_ptr->stock_num++;
 643         st_ptr->stock[slot] = *o_ptr;
 644         return slot;
 645 }