src/knowledge/knowledge-items.c

   1 /*!
   2  * @brief 既知のアイテムとアーティファクトを表示する
   3  * @date 2020/04/23
   4  * @author Hourier
   5  */
   6
   7 #include "knowledge/knowledge-items.h"
   8 #include "core/show-file.h"
   9 #include "core/stuff-handler.h"
  10 #include "floor/floor.h"
  11 #include "game-option/special-options.h"
  12 #include "grid/grid.h"
  13 #include "inventory/inventory-slot-types.h"
  14 #include "io-dump/dump-util.h"
  15 #include "io/input-key-acceptor.h"
  16 #include "knowledge/object-group-table.h"
  17 #include "object-enchant/artifact.h"
  18 #include "object-enchant/special-object-flags.h"
  19 #include "object-hook/hook-enchant.h"
  20 #include "object/object-flavor.h"
  21 #include "object/object-generator.h"
  22 #include "object/object-kind-hook.h"
  23 #include "object/object-kind.h"
  24 #include "perception/identification.h"
  25 #include "perception/object-perception.h"
  26 #include "term/screen-processor.h"
  27 #include "term/term-color-types.h"
  28 #include "util/angband-files.h"
  29 #include "util/int-char-converter.h"
  30 #include "util/sort.h"
  31 #include "view/display-messages.h"
  32 #include "world/world.h"
  33
  34 /*
  35  * todo okay = 既知のアーティファクト？ と思われるが確証がない
  36  * 分かりやすい変数名へ変更求む＆万が一未知である旨の配列なら負論理なのでゴソッと差し替えるべき
  37  * Check the status of "artifacts"
  38  * @param player_ptr プレーヤーへの参照ポインタ
  39  * @return なし
  40  */
  41 void do_cmd_knowledge_artifacts(player_type *player_ptr)
  42 {
  43         FILE *fff = NULL;
  44         GAME_TEXT file_name[FILE_NAME_SIZE];
  45         if (!open_temporary_file(&fff, file_name)) return;
  46
  47         ARTIFACT_IDX *who;
  48         C_MAKE(who, max_a_idx, ARTIFACT_IDX);
  49         bool *okay;
  50         C_MAKE(okay, max_a_idx, bool);
  51
  52         for (ARTIFACT_IDX k = 0; k < max_a_idx; k++)
  53         {
  54                 artifact_type *a_ptr = &a_info[k];
  55                 okay[k] = FALSE;
  56                 if (!a_ptr->name) continue;
  57                 if (!a_ptr->cur_num) continue;
  58
  59                 okay[k] = TRUE;
  60         }
  61
  62         for (POSITION y = 0; y < player_ptr->current_floor_ptr->height; y++)
  63         {
  64                 for (POSITION x = 0; x < player_ptr->current_floor_ptr->width; x++)
  65                 {
  66                         grid_type *g_ptr = &player_ptr->current_floor_ptr->grid_array[y][x];
  67                         OBJECT_IDX this_o_idx, next_o_idx = 0;
  68                         for (this_o_idx = g_ptr->o_idx; this_o_idx; this_o_idx = next_o_idx)
  69                         {
  70                                 object_type *o_ptr;
  71                                 o_ptr = &player_ptr->current_floor_ptr->o_list[this_o_idx];
  72                                 next_o_idx = o_ptr->next_o_idx;
  73                                 if (!object_is_fixed_artifact(o_ptr)) continue;
  74                                 if (object_is_known(o_ptr)) continue;
  75
  76                                 okay[o_ptr->name1] = FALSE;
  77                         }
  78                 }
  79         }
  80
  81         for (ARTIFACT_IDX i = 0; i < INVEN_TOTAL; i++)
  82         {
  83                 object_type *o_ptr = &player_ptr->inventory_list[i];
  84                 if (!o_ptr->k_idx) continue;
  85                 if (!object_is_fixed_artifact(o_ptr)) continue;
  86                 if (object_is_known(o_ptr)) continue;
  87
  88                 okay[o_ptr->name1] = FALSE;
  89         }
  90
  91         int n = 0;
  92         for (ARTIFACT_IDX k = 0; k < max_a_idx; k++)
  93         {
  94                 if (okay[k]) who[n++] = k;
  95         }
  96
  97         u16b why = 3;
  98         ang_sort(player_ptr, who, &why, n, ang_sort_art_comp, ang_sort_art_swap);
  99         for (ARTIFACT_IDX k = 0; k < n; k++)
 100         {
 101                 artifact_type *a_ptr = &a_info[who[k]];
 102                 GAME_TEXT base_name[MAX_NLEN];
 103                 strcpy(base_name, _("未知の伝説のアイテム", "Unknown Artifact"));
 104                 ARTIFACT_IDX z = lookup_kind(a_ptr->tval, a_ptr->sval);
 105                 if (z)
 106                 {
 107                         object_type forge;
 108                         object_type *q_ptr;
 109                         q_ptr = &forge;
 110                         object_prep(player_ptr, q_ptr, z);
 111                         q_ptr->name1 = (byte)who[k];
 112                         q_ptr->ident |= IDENT_STORE;
 113                         object_desc(player_ptr, base_name, q_ptr, (OD_OMIT_PREFIX | OD_NAME_ONLY));
 114                 }
 115
 116                 fprintf(fff, _("     %s\n", "     The %s\n"), base_name);
 117         }
 118
 119         C_KILL(who, max_a_idx, ARTIFACT_IDX);
 120         C_KILL(okay, max_a_idx, bool);
 121         angband_fclose(fff);
 122         (void)show_file(player_ptr, TRUE, file_name, _("既知の伝説のアイテム", "Artifacts Seen"), 0, 0);
 123         fd_kill(file_name);
 124 }
 125
 126
 127 /*
 128  * Build a list of object indexes in the given group. Return the number
 129  * of objects in the group.
 130  *
 131  * mode & 0x01 : check for non-empty group
 132  * mode & 0x02 : visual operation only
 133  */
 134 static KIND_OBJECT_IDX collect_objects(int grp_cur, KIND_OBJECT_IDX object_idx[], BIT_FLAGS8 mode)
 135 {
 136         KIND_OBJECT_IDX object_cnt = 0;
 137         byte group_tval = object_group_tval[grp_cur];
 138         for (KIND_OBJECT_IDX i = 0; i < max_k_idx; i++)
 139         {
 140                 object_kind *k_ptr = &k_info[i];
 141                 if (!k_ptr->name) continue;
 142
 143                 if (!(mode & 0x02))
 144                 {
 145                         if (!current_world_ptr->wizard)
 146                         {
 147                                 if (!k_ptr->flavor) continue;
 148                                 if (!k_ptr->aware) continue;
 149                         }
 150
 151                         int k = 0;
 152                         for (int j = 0; j < 4; j++)
 153                                 k += k_ptr->chance[j];
 154                         if (!k) continue;
 155                 }
 156
 157                 if (TV_LIFE_BOOK == group_tval)
 158                 {
 159                         if (TV_LIFE_BOOK <= k_ptr->tval && k_ptr->tval <= TV_HEX_BOOK)
 160                         {
 161                                 object_idx[object_cnt++] = i;
 162                         }
 163                         else
 164                                 continue;
 165                 }
 166                 else if (k_ptr->tval == group_tval)
 167                 {
 168                         object_idx[object_cnt++] = i;
 169                 }
 170                 else
 171                         continue;
 172
 173                 if (mode & 0x01) break;
 174         }
 175
 176         object_idx[object_cnt] = -1;
 177         return object_cnt;
 178 }
 179
 180
 181 /*
 182  * Display the objects in a group.
 183  */
 184 static void display_object_list(int col, int row, int per_page, IDX object_idx[],
 185         int object_cur, int object_top, bool visual_only)
 186 {
 187         int i;
 188         for (i = 0; i < per_page && (object_idx[object_top + i] >= 0); i++)
 189         {
 190                 GAME_TEXT o_name[MAX_NLEN];
 191                 TERM_COLOR a;
 192                 SYMBOL_CODE c;
 193                 object_kind *flavor_k_ptr;
 194                 KIND_OBJECT_IDX k_idx = object_idx[object_top + i];
 195                 object_kind *k_ptr = &k_info[k_idx];
 196                 TERM_COLOR attr = ((k_ptr->aware || visual_only) ? TERM_WHITE : TERM_SLATE);
 197                 byte cursor = ((k_ptr->aware || visual_only) ? TERM_L_BLUE : TERM_BLUE);
 198                 if (!visual_only && k_ptr->flavor)
 199                 {
 200                         flavor_k_ptr = &k_info[k_ptr->flavor];
 201                 }
 202                 else
 203                 {
 204                         flavor_k_ptr = k_ptr;
 205                 }
 206
 207                 attr = ((i + object_top == object_cur) ? cursor : attr);
 208                 if (!k_ptr->flavor || (!visual_only && k_ptr->aware))
 209                 {
 210                         strip_name(o_name, k_idx);
 211                 }
 212                 else
 213                 {
 214                         strcpy(o_name, k_name + flavor_k_ptr->flavor_name);
 215                 }
 216
 217                 c_prt(attr, o_name, row + i, col);
 218                 if (per_page == 1)
 219                 {
 220                         c_prt(attr, format("%02x/%02x", flavor_k_ptr->x_attr, flavor_k_ptr->x_char), row + i, (current_world_ptr->wizard || visual_only) ? 64 : 68);
 221                 }
 222
 223                 if (current_world_ptr->wizard || visual_only)
 224                 {
 225                         c_prt(attr, format("%d", k_idx), row + i, 70);
 226                 }
 227
 228                 a = flavor_k_ptr->x_attr;
 229                 c = flavor_k_ptr->x_char;
 230
 231                 Term_queue_bigchar(use_bigtile ? 76 : 77, row + i, a, c, 0, 0);
 232         }
 233
 234         for (; i < per_page; i++)
 235         {
 236                 Term_erase(col, row + i, 255);
 237         }
 238 }
 239
 240
 241 /*
 242  * Describe fake object
 243  */
 244 static void desc_obj_fake(player_type *creature_ptr, KIND_OBJECT_IDX k_idx)
 245 {
 246         object_type *o_ptr;
 247         object_type object_type_body;
 248         o_ptr = &object_type_body;
 249         object_wipe(o_ptr);
 250         object_prep(creature_ptr, o_ptr, k_idx);
 251
 252         o_ptr->ident |= IDENT_KNOWN;
 253         handle_stuff(creature_ptr);
 254
 255         if (screen_object(creature_ptr, o_ptr, SCROBJ_FAKE_OBJECT | SCROBJ_FORCE_DETAIL)) return;
 256
 257         msg_print(_("特に変わったところはないようだ。", "You see nothing special."));
 258         msg_print(NULL);
 259 }
 260
 261
 262 /*
 263  * Display known objects
 264  */
 265 void do_cmd_knowledge_objects(player_type *creature_ptr, bool *need_redraw, bool visual_only, IDX direct_k_idx)
 266 {
 267         IDX object_old, object_top;
 268         IDX grp_idx[100];
 269         int object_cnt;
 270         OBJECT_IDX *object_idx;
 271
 272         bool visual_list = FALSE;
 273         TERM_COLOR attr_top = 0;
 274         byte char_left = 0;
 275         byte mode;
 276
 277         TERM_LEN wid, hgt;
 278         Term_get_size(&wid, &hgt);
 279
 280         int browser_rows = hgt - 8;
 281         C_MAKE(object_idx, max_k_idx, KIND_OBJECT_IDX);
 282
 283         int len;
 284         int max = 0;
 285         int grp_cnt = 0;
 286         if (direct_k_idx < 0)
 287         {
 288                 mode = visual_only ? 0x03 : 0x01;
 289                 for (IDX i = 0; object_group_text[i] != NULL; i++)
 290                 {
 291                         len = strlen(object_group_text[i]);
 292                         if (len > max) max = len;
 293
 294                         if (collect_objects(i, object_idx, mode))
 295                         {
 296                                 grp_idx[grp_cnt++] = i;
 297                         }
 298                 }
 299
 300                 object_old = -1;
 301                 object_cnt = 0;
 302         }
 303         else
 304         {
 305                 object_kind *k_ptr = &k_info[direct_k_idx];
 306                 object_kind *flavor_k_ptr;
 307
 308                 if (!visual_only && k_ptr->flavor)
 309                 {
 310                         flavor_k_ptr = &k_info[k_ptr->flavor];
 311                 }
 312                 else
 313                 {
 314                         flavor_k_ptr = k_ptr;
 315                 }
 316
 317                 object_idx[0] = direct_k_idx;
 318                 object_old = direct_k_idx;
 319                 object_cnt = 1;
 320                 object_idx[1] = -1;
 321                 (void)visual_mode_command('v', &visual_list, browser_rows - 1, wid - (max + 3),
 322                         &attr_top, &char_left, &flavor_k_ptr->x_attr, &flavor_k_ptr->x_char, need_redraw);
 323         }
 324
 325         grp_idx[grp_cnt] = -1;
 326         mode = visual_only ? 0x02 : 0x00;
 327         IDX old_grp_cur = -1;
 328         IDX grp_cur = 0;
 329         IDX grp_top = 0;
 330         IDX object_cur = object_top = 0;
 331         bool flag = FALSE;
 332         bool redraw = TRUE;
 333         int column = 0;
 334         while (!flag)
 335         {
 336                 object_kind *k_ptr, *flavor_k_ptr;
 337
 338                 if (redraw)
 339                 {
 340                         clear_from(0);
 341
 342 #ifdef JP
 343                         prt(format("%s - アイテム", !visual_only ? "知識" : "表示"), 2, 0);
 344                         if (direct_k_idx < 0) prt("グループ", 4, 0);
 345                         prt("名前", 4, max + 3);
 346                         if (current_world_ptr->wizard || visual_only) prt("Idx", 4, 70);
 347                         prt("文字", 4, 74);
 348 #else
 349                         prt(format("%s - objects", !visual_only ? "Knowledge" : "Visuals"), 2, 0);
 350                         if (direct_k_idx < 0) prt("Group", 4, 0);
 351                         prt("Name", 4, max + 3);
 352                         if (current_world_ptr->wizard || visual_only) prt("Idx", 4, 70);
 353                         prt("Sym", 4, 75);
 354 #endif
 355
 356                         for (IDX i = 0; i < 78; i++)
 357                         {
 358                                 Term_putch(i, 5, TERM_WHITE, '=');
 359                         }
 360
 361                         if (direct_k_idx < 0)
 362                         {
 363                                 for (IDX i = 0; i < browser_rows; i++)
 364                                 {
 365                                         Term_putch(max + 1, 6 + i, TERM_WHITE, '|');
 366                                 }
 367                         }
 368
 369                         redraw = FALSE;
 370                 }
 371
 372                 if (direct_k_idx < 0)
 373                 {
 374                         if (grp_cur < grp_top) grp_top = grp_cur;
 375                         if (grp_cur >= grp_top + browser_rows) grp_top = grp_cur - browser_rows + 1;
 376
 377                         display_group_list(0, 6, max, browser_rows, grp_idx, object_group_text, grp_cur, grp_top);
 378                         if (old_grp_cur != grp_cur)
 379                         {
 380                                 old_grp_cur = grp_cur;
 381                                 object_cnt = collect_objects(grp_idx[grp_cur], object_idx, mode);
 382                         }
 383
 384                         while (object_cur < object_top)
 385                                 object_top = MAX(0, object_top - browser_rows / 2);
 386                         while (object_cur >= object_top + browser_rows)
 387                                 object_top = MIN(object_cnt - browser_rows, object_top + browser_rows / 2);
 388                 }
 389
 390                 if (!visual_list)
 391                 {
 392                         display_object_list(max + 3, 6, browser_rows, object_idx, object_cur, object_top, visual_only);
 393                 }
 394                 else
 395                 {
 396                         object_top = object_cur;
 397                         display_object_list(max + 3, 6, 1, object_idx, object_cur, object_top, visual_only);
 398                         display_visual_list(max + 3, 7, browser_rows - 1, wid - (max + 3), attr_top, char_left);
 399                 }
 400
 401                 k_ptr = &k_info[object_idx[object_cur]];
 402
 403                 if (!visual_only && k_ptr->flavor)
 404                 {
 405                         flavor_k_ptr = &k_info[k_ptr->flavor];
 406                 }
 407                 else
 408                 {
 409                         flavor_k_ptr = k_ptr;
 410                 }
 411
 412 #ifdef JP
 413                 prt(format("<方向>%s%s%s, ESC",
 414                         (!visual_list && !visual_only) ? ", 'r'で詳細を見る" : "",
 415                         visual_list ? ", ENTERで決定" : ", 'v'でシンボル変更",
 416                         (attr_idx || char_idx) ? ", 'c', 'p'でペースト" : ", 'c'でコピー"),
 417                         hgt - 1, 0);
 418 #else
 419                 prt(format("<dir>%s%s%s, ESC",
 420                         (!visual_list && !visual_only) ? ", 'r' to recall" : "",
 421                         visual_list ? ", ENTER to accept" : ", 'v' for visuals",
 422                         (attr_idx || char_idx) ? ", 'c', 'p' to paste" : ", 'c' to copy"),
 423                         hgt - 1, 0);
 424 #endif
 425
 426                 if (!visual_only)
 427                 {
 428                         if (object_cnt) object_kind_track(creature_ptr, object_idx[object_cur]);
 429
 430                         if (object_old != object_idx[object_cur])
 431                         {
 432                                 handle_stuff(creature_ptr);
 433                                 object_old = object_idx[object_cur];
 434                         }
 435                 }
 436
 437                 if (visual_list)
 438                 {
 439                         place_visual_list_cursor(max + 3, 7, flavor_k_ptr->x_attr, flavor_k_ptr->x_char, attr_top, char_left);
 440                 }
 441                 else if (!column)
 442                 {
 443                         Term_gotoxy(0, 6 + (grp_cur - grp_top));
 444                 }
 445                 else
 446                 {
 447                         Term_gotoxy(max + 3, 6 + (object_cur - object_top));
 448                 }
 449
 450                 char ch = inkey();
 451                 if (visual_mode_command(ch, &visual_list, browser_rows - 1, wid - (max + 3), &attr_top, &char_left, &flavor_k_ptr->x_attr, &flavor_k_ptr->x_char, need_redraw))
 452                 {
 453                         if (direct_k_idx >= 0)
 454                         {
 455                                 switch (ch)
 456                                 {
 457                                 case '\n':
 458                                 case '\r':
 459                                 case ESCAPE:
 460                                         flag = TRUE;
 461                                         break;
 462                                 }
 463                         }
 464                         continue;
 465                 }
 466
 467                 switch (ch)
 468                 {
 469                 case ESCAPE:
 470                 {
 471                         flag = TRUE;
 472                         break;
 473                 }
 474
 475                 case 'R':
 476                 case 'r':
 477                 {
 478                         if (!visual_list && !visual_only && (grp_cnt > 0))
 479                         {
 480                                 desc_obj_fake(creature_ptr, object_idx[object_cur]);
 481                                 redraw = TRUE;
 482                         }
 483
 484                         break;
 485                 }
 486
 487                 default:
 488                 {
 489                         browser_cursor(ch, &column, &grp_cur, grp_cnt, &object_cur, object_cnt);
 490                         break;
 491                 }
 492                 }
 493         }
 494
 495         C_KILL(object_idx, max_k_idx, KIND_OBJECT_IDX);
 496 }