OSDN Git Service

(root) / hengband / hengband.git / blob
? search:


0f3a6896f89245d7110ac005a109f90d7cef2549
[hengband/hengband.git] / src / flavor.c
1 /*!
2  *  @file flavor.c
3  *  @brief ¥ª¥Ö¥¸¥§¥¯¥È¤Îµ­½Ò½èÍý / Mbject flavor code
4  *  @date 2014/01/03
5  *  @author
6  * Copyright (c) 1997 Ben Harrison, James E. Wilson, Robert A. Koeneke\n
7  *\n
8  * This software may be copied and distributed for educational, research,\n
9  * and not for profit purposes provided that this copyright and statement\n
10  * are included in all such copies.  Other copyrights may also apply.\n
11  */
12
13 #include "angband.h"
14
15 /*!
16  * @brief ºÇ½é¤«¤é´Ê°×¤Ê̾¾Î¤¬ÌÀ¤é¤«¤Ë¤Ê¤ë¥Ù¡¼¥¹¥¢¥¤¥Æ¥à¤ÎȽÄê¡£ /  Certain items, if aware, are known instantly 
17  * @param i ¥Ù¡¼¥¹¥¢¥¤¥Æ¥àID
18  * @return ´Ê°×̾¾Î¤òÌÀ¤é¤«¤Ë¤¹¤ë¤Ê¤éTRUE¤òÊÖ¤¹¡£
19  * @details
20  * This function is used only by "flavor_init()"
21  */
22 static bool object_easy_know(int i)
23 {
24         object_kind *k_ptr = &k_info[i];
25
26         /* Analyze the "tval" */
27         switch (k_ptr->tval)
28         {
29                 /* Spellbooks */
30                 case TV_LIFE_BOOK:
31                 case TV_SORCERY_BOOK:
32                 case TV_NATURE_BOOK:
33                 case TV_CHAOS_BOOK:
34                 case TV_DEATH_BOOK:
35                 case TV_TRUMP_BOOK:
36                 case TV_ARCANE_BOOK:
37                 case TV_CRAFT_BOOK:
38                 case TV_DAEMON_BOOK:
39                 case TV_CRUSADE_BOOK:
40                 case TV_MUSIC_BOOK:
41                 case TV_HISSATSU_BOOK:
42                 case TV_HEX_BOOK:
43                 {
44                         return (TRUE);
45                 }
46
47                 /* Simple items */
48                 case TV_FLASK:
49                 case TV_JUNK:
50                 case TV_BOTTLE:
51                 case TV_SKELETON:
52                 case TV_SPIKE:
53                 case TV_WHISTLE:
54                 {
55                         return (TRUE);
56                 }
57
58                 /* All Food, Potions, Scrolls, Rods */
59                 case TV_FOOD:
60                 case TV_POTION:
61                 case TV_SCROLL:
62                 case TV_ROD:
63                 {
64                         return (TRUE);
65                 }
66         }
67
68         /* Nope */
69         return (FALSE);
70 }
71
72 /*!
73  * @brief ³Æ¼ï¸ì×䫤é¥é¥ó¥À¥à¤Ê̾Á°¤òºîÀ®¤¹¤ë / Create a name from random parts.
74  * @param out_string ºîÀ®¤·¤¿Ì¾¤òÊݴɤ¹¤ë»²¾È¥Ý¥¤¥ó¥¿
75  * @return ¤Ê¤·
76  * @details ÆüËܸì¤Î¾ì¹ç aname_j.txt ±Ñ¸ì¤Î¾ì¹ç³ÎΨ¤Ë±þ¤¸¤Æ
77  * syllables ÇÛÎó¤È elvish.txt ¤òÁȤ߹ç¤ï¤»¤ë¡£\n
78  */
79 void get_table_name_aux(char *out_string)
80 {
81 #ifdef JP
82         char Syllable[80];
83         get_rnd_line("aname_j.txt", 1, Syllable);
84         strcpy(out_string, Syllable);
85         get_rnd_line("aname_j.txt", 2, Syllable);
86         strcat(out_string, Syllable);
87 #else
88 #define MAX_SYLLABLES 164       /* Used with scrolls (see below) */
89
90         static cptr syllables[MAX_SYLLABLES] = {
91                 "a", "ab", "ag", "aks", "ala", "an", "ankh", "app",
92                 "arg", "arze", "ash", "aus", "ban", "bar", "bat", "bek",
93                 "bie", "bin", "bit", "bjor", "blu", "bot", "bu",
94                 "byt", "comp", "con", "cos", "cre", "dalf", "dan",
95                 "den", "der", "doe", "dok", "eep", "el", "eng", "er", "ere", "erk",
96                 "esh", "evs", "fa", "fid", "flit", "for", "fri", "fu", "gan",
97                 "gar", "glen", "gop", "gre", "ha", "he", "hyd", "i",
98                 "ing", "ion", "ip", "ish", "it", "ite", "iv", "jo",
99                 "kho", "kli", "klis", "la", "lech", "man", "mar",
100                 "me", "mi", "mic", "mik", "mon", "mung", "mur", "nag", "nej",
101                 "nelg", "nep", "ner", "nes", "nis", "nih", "nin", "o",
102                 "od", "ood", "org", "orn", "ox", "oxy", "pay", "pet",
103                 "ple", "plu", "po", "pot", "prok", "re", "rea", "rhov",
104                 "ri", "ro", "rog", "rok", "rol", "sa", "san", "sat",
105                 "see", "sef", "seh", "shu", "ski", "sna", "sne", "snik",
106                 "sno", "so", "sol", "sri", "sta", "sun", "ta", "tab",
107                 "tem", "ther", "ti", "tox", "trol", "tue", "turs", "u",
108                 "ulk", "um", "un", "uni", "ur", "val", "viv", "vly",
109                 "vom", "wah", "wed", "werg", "wex", "whon", "wun", "x",
110                 "yerg", "yp", "zun", "tri", "blaa", "jah", "bul", "on",
111                 "foo", "ju", "xuxu"
112         };
113
114         int testcounter = randint1(3) + 1;
115
116         strcpy(out_string, "");
117
118         if (randint1(3) == 2)
119         {
120                 while (testcounter--)
121                         strcat(out_string, syllables[randint0(MAX_SYLLABLES)]);
122         }
123         else
124         {
125                 char Syllable[80];
126                 testcounter = randint1(2) + 1;
127                 while (testcounter--)
128                 {
129                         (void)get_rnd_line("elvish.txt", 0, Syllable);
130                         strcat(out_string, Syllable);
131                 }
132         }
133
134         out_string[0] = toupper(out_string[1]);
135
136         out_string[16] = '\0';
137 #endif
138 }
139
140 /*!
141  * @brief ¥é¥ó¥À¥à¤Ê̾Á°¤ò¥¢¡¼¥Æ¥£¥Õ¥¡¥¯¥ÈÌäȤ·¤ÆÀ°·Á¤¹¤ë¡£ / Create a name from random parts with quotes.
142  * @param out_string ºîÀ®¤·¤¿Ì¾¤òÊݴɤ¹¤ë»²¾È¥Ý¥¤¥ó¥¿
143  * @return ¤Ê¤·
144  * @details get_table_name_aux()¤Û¤Ü´°Á´¤Ë¼ÂÁõ¤ò°Í¸¤·¤Æ¤¤¤ë¡£
145  */
146 void get_table_name(char *out_string)
147 {
148         char buff[80];
149         get_table_name_aux(buff);
150
151 #ifdef JP
152         sprintf(out_string, "¡Ø%s¡Ù", buff);
153 #else
154         sprintf(out_string, "'%s'", buff);
155 #endif
156 }
157
158 /*!
159  * @brief ¥é¥ó¥À¥à¤Ê¥·¥ó¥À¥ê¥óÌäòºîÀ®¤¹¤ë / Make random Sindarin name
160  * @param out_string ºîÀ®¤·¤¿Ì¾¤òÊݴɤ¹¤ë»²¾È¥Ý¥¤¥ó¥¿
161  * @return ¤Ê¤·
162  * @details sname.txt¤¬¸ì´´¤Î¼­½ñ¤È¤Ê¤Ã¤Æ¤¤¤ë¡£
163  */
164 void get_table_sindarin_aux(char *out_string)
165 {
166         char Syllable[80];
167 #ifdef JP
168         char tmp[80];
169 #endif
170
171         get_rnd_line("sname.txt", 1, Syllable);
172 #ifdef JP
173         strcpy(tmp, Syllable);
174 #else
175         strcpy(out_string, Syllable);
176 #endif
177
178         get_rnd_line("sname.txt", 2, Syllable);
179 #ifdef JP
180         strcat(tmp, Syllable);
181         sindarin_to_kana(out_string, tmp);
182 #else
183         strcat(out_string, Syllable);
184 #endif
185 }
186
187 /*!
188  * @brief ¥·¥ó¥À¥ê¥óÌäò¥¢¡¼¥Æ¥£¥Õ¥¡¥¯¥ÈÍѤËÀ°·Á¤¹¤ë¡£ / Make random Sindarin name with quotes
189  * @param out_string ºîÀ®¤·¤¿Ì¾¤òÊݴɤ¹¤ë»²¾È¥Ý¥¤¥ó¥¿
190  * @return ¤Ê¤·
191  * @details get_table_sindarin_aux()¤Û¤Ü´°Á´¤Ë¼ÂÁõ¤ò°Í¸¤·¤Æ¤¤¤ë¡£
192  */
193 void get_table_sindarin(char *out_string)
194 {
195         char buff[80];
196         get_table_sindarin_aux(buff);
197
198 #ifdef JP
199         sprintf(out_string, "¡Ø%s¡Ù", buff);
200 #else
201         sprintf(out_string, "'%s'", buff);
202 #endif
203 }
204
205
206 /*!
207  * @brief ¥Ù¡¼¥¹¥¢¥¤¥Æ¥à¤Î̤³ÎÄê̾¤ò¶¦ÄÌtval´Ö¤Ç¥·¥ã¥Ã¥Õ¥ë¤¹¤ë / Shuffle flavor indices of a group of objects with given tval
208  * @param byte ¥·¥ã¥Ã¥Õ¥ë¤·¤¿¤¤tval
209  * @return ¤Ê¤·
210  * @details ´¬Êª¡¢³Æ¼ïËâÆ»¶ñ¤Ê¤É¤ËÍøÍѤµ¤ì¤ë¡£
211  */
212 static void shuffle_flavors(byte tval)
213 {
214         s16b *k_idx_list;
215         int k_idx_list_num = 0;
216         int i;
217
218         /* Allocate an array for a list of k_idx */
219         C_MAKE(k_idx_list, max_k_idx, s16b);
220
221         /* Search objects with given tval for shuffle */
222         for (i = 0; i < max_k_idx; i++)
223         {
224                 object_kind *k_ptr = &k_info[i];
225
226                 /* Skip non-Rings */
227                 if (k_ptr->tval != tval) continue;
228
229                 /* Paranoia -- Skip objects without flavor */
230                 if (!k_ptr->flavor) continue;
231
232                 /* Skip objects with a fixed flavor name */
233                 if (have_flag(k_ptr->flags, TR_FIXED_FLAVOR)) continue;
234
235                 /* Remember k_idx */
236                 k_idx_list[k_idx_list_num] = i;
237
238                 /* Increase number of remembered indices */
239                 k_idx_list_num++;
240         }
241
242         /* Shuffle flavors */
243         for (i = 0; i < k_idx_list_num; i++)
244         {
245                 object_kind *k1_ptr = &k_info[k_idx_list[i]];
246                 object_kind *k2_ptr = &k_info[k_idx_list[randint0(k_idx_list_num)]];
247
248                 /* Swap flavors of this pair */
249                 s16b tmp = k1_ptr->flavor;
250                 k1_ptr->flavor = k2_ptr->flavor;
251                 k2_ptr->flavor = tmp;
252         }
253
254         /* Free an array for a list of k_idx */
255         C_KILL(k_idx_list, max_k_idx, s16b);
256 }
257
258 /*!
259  * @brief ¥²¡¼¥à³«»Ï»þ¤Ë¹Ô¤ï¤ì¤ë¥Ù¡¼¥¹¥¢¥¤¥Æ¥à¤Î½é´ü²½¥ë¡¼¥Á¥ó / Prepare the "variable" part of the "k_info" array.
260  * @return ¤Ê¤·
261  * @details
262  * Prepare the "variable" part of the "k_info" array.\n
263  *\n
264  * The "color"/"metal"/"type" of an item is its "flavor".\n
265  * For the most part, flavors are assigned randomly each game.\n
266  *\n
267  * Initialize descriptions for the "colored" objects, including:\n
268  * Rings, Amulets, Staffs, Wands, Rods, Food, Potions, Scrolls.\n
269  *\n
270  * The first 4 entries for potions are fixed (Water, Apple Juice,\n
271  * Slime Mold Juice, Unused Potion).\n
272  *\n
273  * Scroll titles are always between 6 and 14 letters long.  This is\n
274  * ensured because every title is composed of whole words, where every\n
275  * word is from 1 to 8 letters long (one or two syllables of 1 to 4\n
276  * letters each), and that no scroll is finished until it attempts to\n
277  * grow beyond 15 letters.  The first time this can happen is when the\n
278  * current title has 6 letters and the new word has 8 letters, which\n
279  * would result in a 6 letter scroll title.\n
280  *\n
281  * Duplicate titles are avoided by requiring that no two scrolls share\n
282  * the same first four letters (not the most efficient method, and not\n
283  * the least efficient method, but it will always work).\n
284  *\n
285  * Hack -- make sure everything stays the same for each saved game\n
286  * This is accomplished by the use of a saved "random seed", as in\n
287  * "town_gen()".  Since no other functions are called while the special\n
288  * seed is in effect, so this function is pretty "safe".\n
289  *\n
290  * Note that the "hacked seed" may provide an RNG with alternating parity!\n
291  */
292 void flavor_init(void)
293 {
294         int i;
295         u32b state_backup[4];
296
297         /* Hack -- Backup the RNG state */
298         Rand_state_backup(state_backup);
299
300         /* Hack -- Induce consistant flavors */
301         Rand_state_init(seed_flavor);
302
303
304         /* Initialize flavor index of each object by itself */
305         for (i = 0; i < max_k_idx; i++)
306         {
307                 object_kind *k_ptr = &k_info[i];
308
309                 /* Skip objects without flavor name */
310                 if (!k_ptr->flavor_name) continue;
311
312                 /*
313                  * Initialize flavor index to itself
314                  *  -> Shuffle it later
315                  */
316                 k_ptr->flavor = i;
317         }
318
319         /* Shuffle Rings */
320         shuffle_flavors(TV_RING);
321
322         /* Shuffle Amulets */
323         shuffle_flavors(TV_AMULET);
324
325         /* Shuffle Staves */
326         shuffle_flavors(TV_STAFF);
327
328         /* Shuffle Wands */
329         shuffle_flavors(TV_WAND);
330
331         /* Shuffle Rods */
332         shuffle_flavors(TV_ROD);
333
334         /* Shuffle Mushrooms */
335         shuffle_flavors(TV_FOOD);
336
337         /* Shuffle Potions */
338         shuffle_flavors(TV_POTION);
339
340         /* Shuffle Scrolls */
341         shuffle_flavors(TV_SCROLL);
342
343
344         /* Hack -- Restore the RNG state */
345         Rand_state_restore(state_backup);
346
347         /* Analyze every object */
348         for (i = 1; i < max_k_idx; i++)
349         {
350                 object_kind *k_ptr = &k_info[i];
351
352                 /* Skip "empty" objects */
353                 if (!k_ptr->name) continue;
354
355                 /* No flavor yields aware */
356                 if (!k_ptr->flavor) k_ptr->aware = TRUE;
357
358                 /* Check for "easily known" */
359                 k_ptr->easy_know = object_easy_know(i);
360         }
361 }
362
363
364 /*!
365  * @brief ÂоÝʸ»úÇÛÎó¤Ë°ìʸ»ú¤À¤±¤ò¥³¥Ô¡¼¤¹¤ë¡£
366  * @param t ÊÝ´ÉÀèʸ»úÎó¥Ý¥¤¥ó¥¿
367  * @param c Êݴɤ·¤¿¤¤1ʸ»ú
368  * @return ¤Ê¤·
369  * @details
370  * Print a char "c" into a string "t", as if by sprintf(t, "%c", c),\n
371  * and return a pointer to the terminator (t + 1).\n
372  */
373 static char *object_desc_chr(char *t, char c)
374 {
375         /* Copy the char */
376         *t++ = c;
377
378         /* Terminate */
379         *t = '\0';
380
381         /* Result */
382         return (t);
383 }
384
385 /*!
386  * @brief ÂоÝʸ»úÇÛÎó¤Ëʸ»úÎó¤ò¥³¥Ô¡¼¤¹¤ë¡£
387  * @param t ÊÝ´ÉÀèʸ»úÎó¥Ý¥¤¥ó¥¿
388  * @param c ¥³¥Ô¡¼¤·¤¿¤¤Ê¸»úÎó¥Ý¥¤¥ó¥¿
389  * @return ¤Ê¤·
390  * @details
391  * Print a string "s" into a string "t", as if by strcpy(t, s),
392  * and return a pointer to the terminator.
393  */
394 static char *object_desc_str(char *t, cptr s)
395 {
396         /* Copy the string */
397         while (*s) *t++ = *s++;
398
399         /* Terminate */
400         *t = '\0';
401
402         /* Result */
403         return (t);
404 }
405
406 /*!
407  * @brief ÂоÝʸ»úÇÛÎó¤ËÉä¹æ¤Ê¤·À°¿ôÃͤò¥³¥Ô¡¼¤¹¤ë¡£
408  * @param t ÊÝ´ÉÀèʸ»úÎó¥Ý¥¤¥ó¥¿
409  * @param n ¥³¥Ô¡¼¤·¤¿¤¤¿ôÃÍ
410  * @return ¤Ê¤·
411  * @details
412  * Print an unsigned number "n" into a string "t", as if by
413  * sprintf(t, "%u", n), and return a pointer to the terminator.
414  */
415 static char *object_desc_num(char *t, uint n)
416 {
417         uint p;
418
419         /* Find "size" of "n" */
420         for (p = 1; n >= p * 10; p = p * 10) /* loop */;
421
422         /* Dump each digit */
423         while (p >= 1)
424         {
425                 /* Dump the digit */
426                 *t++ = '0' + n / p;
427
428                 /* Remove the digit */
429                 n = n % p;
430
431                 /* Process next digit */
432                 p = p / 10;
433         }
434
435         /* Terminate */
436         *t = '\0';
437
438         /* Result */
439         return (t);
440 }
441
442
443
444
445 #ifdef JP
446 /*!
447  * @brief ÆüËܸì¤Î¸Ä¿ôɽ¼¨¥ë¡¼¥Á¥ó
448  * @param t ÊÝ´ÉÀèʸ»úÎó¥Ý¥¤¥ó¥¿
449  * @param o_ptr µ­½Ò¤·¤¿¤¤¥ª¥Ö¥¸¥§¥¯¥È¤Î¹½Â¤Âλ²¾È¥Ý¥¤¥ó¥¿
450  * @return ¤Ê¤·
451  * @details
452  * cmd1.c ¤ÇήÍѤ¹¤ë¤¿¤á¤Ë object_desc_japanese ¤«¤é°ÜÆ°¤·¤¿¡£
453  */
454 char *object_desc_kosuu(char *t, object_type *o_ptr)
455 {
456     t = object_desc_num(t, o_ptr->number);
457
458     switch (o_ptr->tval)
459     {
460       case TV_BOLT:
461       case TV_ARROW:
462       case TV_POLEARM:
463       case TV_STAFF:
464       case TV_WAND:
465       case TV_ROD:
466       case TV_DIGGING:
467       {
468           t = object_desc_str(t, "ËÜ");
469           break;
470       }
471       case TV_SCROLL:
472       {
473           t = object_desc_str(t, "´¬");
474           break;
475       }
476       case TV_POTION:
477       {
478           t = object_desc_str(t, "Éþ");
479           break;
480       }
481       case  TV_LIFE_BOOK:
482       case  TV_SORCERY_BOOK:
483       case  TV_NATURE_BOOK:
484       case  TV_CHAOS_BOOK:
485       case  TV_DEATH_BOOK:
486       case  TV_TRUMP_BOOK:
487       case  TV_ARCANE_BOOK:
488       case  TV_CRAFT_BOOK:
489       case  TV_DAEMON_BOOK:
490       case  TV_CRUSADE_BOOK:
491       case  TV_MUSIC_BOOK:
492       case  TV_HISSATSU_BOOK:
493           case TV_HEX_BOOK:
494       {
495           t = object_desc_str(t, "ºý");
496           break;
497       }
498       case TV_SOFT_ARMOR:
499       case TV_HARD_ARMOR:
500       case TV_DRAG_ARMOR:
501       case TV_CLOAK:
502       {
503           t = object_desc_str(t, "Ãå");
504           break;
505       }
506       case TV_SWORD:
507       case TV_HAFTED:
508       case TV_BOW:
509       {
510           t = object_desc_str(t, "¿¶");
511           break;
512       }
513       case TV_BOOTS:
514       {
515           t = object_desc_str(t, "­");
516           break;
517       }
518       case TV_CARD:
519       {
520           t = object_desc_str(t, "Ëç");
521           break;
522       }
523             /* ¿©¤Ù¤â¤Î by ita */
524       case TV_FOOD:
525       {
526           if(o_ptr->sval == SV_FOOD_JERKY)
527           {
528               t = object_desc_str(t, "ÀÚ¤ì");
529               break;
530           }
531       }
532       default:
533       {
534           if (o_ptr->number < 10)
535           {
536               t = object_desc_str(t, "¤Ä");
537           }
538           else
539           {
540               t = object_desc_str(t, "¸Ä");
541           }
542           break;
543       }
544   }
545   return (t);                  
546 }
547 #endif
548
549 /*!
550  * @brief ÂоÝʸ»úÇÛÎó¤ËÉä¹æ¤¢¤êÀ°¿ôÃͤò¥³¥Ô¡¼¤¹¤ë¡£
551  * @param t ÊÝ´ÉÀèʸ»úÎó¥Ý¥¤¥ó¥¿
552  * @param v ¥³¥Ô¡¼¤·¤¿¤¤¿ôÃÍ
553  * @return ¤Ê¤·
554  * @details
555  * Print an signed number "v" into a string "t", as if by
556  * sprintf(t, "%+d", n), and return a pointer to the terminator.
557  * Note that we always print a sign, either "+" or "-".
558  */
559 static char *object_desc_int(char *t, sint v)
560 {
561         uint p, n;
562
563         /* Negative */
564         if (v < 0)
565         {
566                 /* Take the absolute value */
567                 n = 0 - v;
568
569                 /* Use a "minus" sign */
570                 *t++ = '-';
571         }
572
573         /* Positive (or zero) */
574         else
575         {
576                 /* Use the actual number */
577                 n = v;
578
579                 /* Use a "plus" sign */
580                 *t++ = '+';
581         }
582
583         /* Find "size" of "n" */
584         for (p = 1; n >= p * 10; p = p * 10) /* loop */;
585
586         /* Dump each digit */
587         while (p >= 1)
588         {
589                 /* Dump the digit */
590                 *t++ = '0' + n / p;
591
592                 /* Remove the digit */
593                 n = n % p;
594
595                 /* Process next digit */
596                 p = p / 10;
597         }
598
599         /* Terminate */
600         *t = '\0';
601
602         /* Result */
603         return (t);
604 }
605
606
607 /*!
608  * ¥ª¥Ö¥¸¥§¥¯¥È¤ÎÆÃÀ­É½¼¨µ­¹æ¥Æ¡¼¥Ö¥ë¤Î¹½Â¤ÂΠ/ Structs and tables for Auto Inscription for flags
609  */
610 typedef struct flag_insc_table
611 {
612 #ifdef JP
613         cptr japanese;
614 #endif
615         cptr english;
616         int flag;
617         int except_flag;
618 } flag_insc_table;
619
620 #ifdef JP
621 /*! ¥ª¥Ö¥¸¥§¥¯¥È¤ÎÆÃÀ­É½¼¨µ­¹æ¥Æ¡¼¥Ö¥ë¤ÎÄêµÁ(pvalÍ×ÁÇ) */
622 static flag_insc_table flag_insc_plus[] =
623 {
624         { "¹¶", "At", TR_BLOWS, -1 },
625         { "®", "Sp", TR_SPEED, -1 },
626         { "ÏÓ", "St", TR_STR, -1 },
627         { "ÃÎ", "In", TR_INT, -1 },
628         { "¸­", "Wi", TR_WIS, -1 },
629         { "´ï", "Dx", TR_DEX, -1 },
630         { "ÂÑ", "Cn", TR_CON, -1 },
631         { "̥", "Ch", TR_CHR, -1 },
632         { "ƻ", "Md", TR_MAGIC_MASTERY, -1 },
633         { "±£", "Sl", TR_STEALTH, -1 },
634         { "õ", "Sr", TR_SEARCH, -1 },
635         { "ÀÖ", "If", TR_INFRA, -1 },
636         { "·¡", "Dg", TR_TUNNEL, -1 },
637         { NULL, NULL, 0, -1 }
638 };
639
640 /*! ¥ª¥Ö¥¸¥§¥¯¥È¤ÎÆÃÀ­É½¼¨µ­¹æ¥Æ¡¼¥Ö¥ë¤ÎÄêµÁ(ÌȱÖ) */
641 static flag_insc_table flag_insc_immune[] =
642 {
643         { "»À", "Ac", TR_IM_ACID, -1 },
644         { "ÅÅ", "El", TR_IM_ELEC, -1 },
645         { "²Ð", "Fi", TR_IM_FIRE, -1 },
646         { "Îä", "Co", TR_IM_COLD, -1 },
647         { NULL, NULL, 0, -1 }
648 };
649
650 /*! ¥ª¥Ö¥¸¥§¥¯¥È¤ÎÆÃÀ­É½¼¨µ­¹æ¥Æ¡¼¥Ö¥ë¤ÎÄêµÁ(ÂÑÀ­) */
651 static flag_insc_table flag_insc_resistance[] =
652 {
653         { "»À", "Ac", TR_RES_ACID, TR_IM_ACID },
654         { "ÅÅ", "El", TR_RES_ELEC, TR_IM_ELEC },
655         { "²Ð", "Fi", TR_RES_FIRE, TR_IM_FIRE },
656         { "Îä", "Co", TR_RES_COLD, TR_IM_COLD },
657         { "ÆÇ", "Po", TR_RES_POIS, -1 },
658         { "Á®", "Li", TR_RES_LITE, -1 },
659         { "°Å", "Dk", TR_RES_DARK, -1 },
660         { "ÇË", "Sh", TR_RES_SHARDS, -1 },
661         { "ÌÕ", "Bl", TR_RES_BLIND, -1 },
662         { "Íð", "Cf", TR_RES_CONF, -1 },
663         { "¹ì", "So", TR_RES_SOUND, -1 },
664         { "¹ö", "Nt", TR_RES_NETHER, -1 },
665         { "°ø", "Nx", TR_RES_NEXUS, -1 },
666         { "ÆÙ", "Ca", TR_RES_CHAOS, -1 },
667         { "Îô", "Di", TR_RES_DISEN, -1 },
668         { "¶²", "Fe", TR_RES_FEAR, -1 },
669         { NULL, NULL, 0, -1 }
670 };
671
672 /*! ¥ª¥Ö¥¸¥§¥¯¥È¤ÎÆÃÀ­É½¼¨µ­¹æ¥Æ¡¼¥Ö¥ë¤ÎÄêµÁ(¤½¤Î¾ÆÃÀ­) */
673 static flag_insc_table flag_insc_misc[] =
674 {
675         { "°×", "Es", TR_EASY_SPELL, -1 },
676         { "¸º", "Dm", TR_DEC_MANA, -1 },
677         { "Åê", "Th", TR_THROW, -1 },
678         { "ȿ", "Rf", TR_REFLECT, -1 },
679         { "Ëã", "Fa", TR_FREE_ACT, -1 },
680         { "»ë", "Si", TR_SEE_INVIS, -1 },
681         { "·Ð", "Hl", TR_HOLD_LIFE, -1 },
682         { "ÃÙ", "Sd", TR_SLOW_DIGEST, -1 },
683         { "³è", "Rg", TR_REGEN, -1 },
684         { "Éâ", "Lv", TR_LEVITATION, -1 },
685         { "ÌÀ", "Lu", TR_LITE_1, -1 },
686         { "ÌÀ", "Lu", TR_LITE_2, -1 },
687         { "ÌÀ", "Lu", TR_LITE_3, -1 },
688         { "°Ç", "Dl", TR_LITE_M1, -1 },
689         { "°Ç", "Dl", TR_LITE_M2, -1 },
690         { "°Ç", "Dl", TR_LITE_M3, -1 },
691         { "·Ù", "Wr", TR_WARNING, -1 },
692         { "ÇÜ", "Xm", TR_XTRA_MIGHT, -1 },
693         { "¼Í", "Xs", TR_XTRA_SHOTS, -1 },
694         { "½Ö", "Te", TR_TELEPORT, -1 },
695         { "ÅÜ", "Ag", TR_AGGRAVATE, -1 },
696         { "½Ë", "Bs", TR_BLESSED, -1 },
697         { "´÷", "Ty", TR_TY_CURSE, -1 },
698         { "¼ö", "C-", TR_ADD_L_CURSE, -1 },
699         { "ëÇ", "C+", TR_ADD_H_CURSE, -1 },
700         { NULL, NULL, 0, -1 }
701 };
702
703 /*! ¥ª¥Ö¥¸¥§¥¯¥È¤ÎÆÃÀ­É½¼¨µ­¹æ¥Æ¡¼¥Ö¥ë¤ÎÄêµÁ(¥ª¡¼¥é) */
704 static flag_insc_table flag_insc_aura[] =
705 {
706         { "±ê", "F", TR_SH_FIRE, -1 },
707         { "ÅÅ", "E", TR_SH_ELEC, -1 },
708         { "Îä", "C", TR_SH_COLD, -1 },
709         { "Ëâ", "M", TR_NO_MAGIC, -1 },
710         { "½Ö", "T", TR_NO_TELE, -1 },
711         { NULL, NULL, 0, -1 }
712 };
713
714 /*! ¥ª¥Ö¥¸¥§¥¯¥È¤ÎÆÃÀ­É½¼¨µ­¹æ¥Æ¡¼¥Ö¥ë¤ÎÄêµÁ(°À­¥¹¥ì¥¤) */
715 static flag_insc_table flag_insc_brand[] =
716 {
717         { "»À", "A", TR_BRAND_ACID, -1 },
718         { "ÅÅ", "E", TR_BRAND_ELEC, -1 },
719         { "¾Æ", "F", TR_BRAND_FIRE, -1 },
720         { "Åà", "Co", TR_BRAND_COLD, -1 },
721         { "ÆÇ", "P", TR_BRAND_POIS, -1 },
722         { "ÆÙ", "Ca", TR_CHAOTIC, -1 },
723         { "µÛ", "V", TR_VAMPIRIC, -1 },
724         { "¿Ì", "Q", TR_IMPACT, -1 },
725         { "ÀÚ", "S", TR_VORPAL, -1 },
726         { "Íý", "M", TR_FORCE_WEAPON, -1 },
727         { NULL, NULL, 0, -1 }
728 };
729
730 /*! ¥ª¥Ö¥¸¥§¥¯¥È¤ÎÆÃÀ­É½¼¨µ­¹æ¥Æ¡¼¥Ö¥ë¤ÎÄêµÁ(¼ï²¥¹¥ì¥¤) */
731 static flag_insc_table flag_insc_kill[] =
732 {
733         { "¼Ù", "*", TR_KILL_EVIL, -1 },
734         { "¿Í", "p", TR_KILL_HUMAN, -1 },
735         { "ζ", "D", TR_KILL_DRAGON, -1 },
736         { "¥ª", "o", TR_KILL_ORC, -1 },
737         { "¥È", "T", TR_KILL_TROLL, -1 },
738         { "µð", "P", TR_KILL_GIANT, -1 },
739         { "¥Ç", "U", TR_KILL_DEMON, -1 },
740         { "»à", "L", TR_KILL_UNDEAD, -1 },
741         { "ư", "Z", TR_KILL_ANIMAL, -1 },
742         { NULL, NULL, 0, -1 }
743 };
744
745 /*! ¥ª¥Ö¥¸¥§¥¯¥È¤ÎÆÃÀ­É½¼¨µ­¹æ¥Æ¡¼¥Ö¥ë¤ÎÄêµÁ(¼ï²*¥¹¥ì¥¤*) */
746 static flag_insc_table flag_insc_slay[] =
747 {
748         { "¼Ù", "*", TR_SLAY_EVIL, TR_KILL_EVIL },
749         { "¿Í", "p", TR_SLAY_HUMAN, TR_KILL_HUMAN },
750         { "ε", "D", TR_SLAY_DRAGON, TR_KILL_DRAGON },
751         { "¥ª", "o", TR_SLAY_ORC, TR_KILL_ORC },
752         { "¥È", "T", TR_SLAY_TROLL, TR_KILL_TROLL },
753         { "µð", "P", TR_SLAY_GIANT, TR_KILL_GIANT },
754         { "¥Ç", "U", TR_SLAY_DEMON, TR_KILL_DEMON },
755         { "»à", "L", TR_SLAY_UNDEAD, TR_KILL_UNDEAD },
756         { "ư", "Z", TR_SLAY_ANIMAL, TR_KILL_ANIMAL },
757         { NULL, NULL, 0, -1 }
758 };
759
760 /*! ¥ª¥Ö¥¸¥§¥¯¥È¤ÎÆÃÀ­É½¼¨µ­¹æ¥Æ¡¼¥Ö¥ë¤ÎÄêµÁ(ESP1) */
761 static flag_insc_table flag_insc_esp1[] =
762 {
763         { "´¶", "Tele", TR_TELEPATHY, -1 },
764         { "¼Ù", "Evil", TR_ESP_EVIL, -1 },
765         { "Á±", "Good", TR_ESP_GOOD, -1 },
766         { "̵", "Nolv", TR_ESP_NONLIVING, -1 },
767         { "¸Ä", "Uniq", TR_ESP_UNIQUE, -1 },
768         { NULL, NULL, 0, -1 }
769 };
770
771 /*! ¥ª¥Ö¥¸¥§¥¯¥È¤ÎÆÃÀ­É½¼¨µ­¹æ¥Æ¡¼¥Ö¥ë¤ÎÄêµÁ(ESP2) */
772 static flag_insc_table flag_insc_esp2[] =
773 {
774         { "¿Í", "p", TR_ESP_HUMAN, -1 },
775         { "ε", "D", TR_ESP_DRAGON, -1 },
776         { "¥ª", "o", TR_ESP_ORC, -1 },
777         { "¥È", "T", TR_ESP_TROLL, -1 },
778         { "µð", "P", TR_ESP_GIANT, -1 },
779         { "¥Ç", "U", TR_ESP_DEMON, -1 },
780         { "»à", "L", TR_ESP_UNDEAD, -1 },
781         { "ư", "Z", TR_ESP_ANIMAL, -1 },
782         { NULL, NULL, 0, -1 }
783 };
784
785 /*! ¥ª¥Ö¥¸¥§¥¯¥È¤ÎÆÃÀ­É½¼¨µ­¹æ¥Æ¡¼¥Ö¥ë¤ÎÄêµÁ(ǽÎÏ°Ý»ý) */
786 static flag_insc_table flag_insc_sust[] =
787 {
788         { "ÏÓ", "St", TR_SUST_STR, -1 },
789         { "ÃÎ", "In", TR_SUST_INT, -1 },
790         { "¸­", "Wi", TR_SUST_WIS, -1 },
791         { "´ï", "Dx", TR_SUST_DEX, -1 },
792         { "ÂÑ", "Cn", TR_SUST_CON, -1 },
793         { "̥", "Ch", TR_SUST_CHR, -1 },
794         { NULL, NULL, 0, -1 }
795 };
796
797 #else
798 static flag_insc_table flag_insc_plus[] =
799 {
800         { "At", TR_BLOWS, -1 },
801         { "Sp", TR_SPEED, -1 },
802         { "St", TR_STR, -1 },
803         { "In", TR_INT, -1 },
804         { "Wi", TR_WIS, -1 },
805         { "Dx", TR_DEX, -1 },
806         { "Cn", TR_CON, -1 },
807         { "Ch", TR_CHR, -1 },
808         { "Md", TR_MAGIC_MASTERY, -1 },
809         { "Sl", TR_STEALTH, -1 },
810         { "Sr", TR_SEARCH, -1 },
811         { "If", TR_INFRA, -1 },
812         { "Dg", TR_TUNNEL, -1 },
813         { NULL, 0, -1 }
814 };
815
816 static flag_insc_table flag_insc_immune[] =
817 {
818         { "Ac", TR_IM_ACID, -1 },
819         { "El", TR_IM_ELEC, -1 },
820         { "Fi", TR_IM_FIRE, -1 },
821         { "Co", TR_IM_COLD, -1 },
822         { NULL, 0, -1 }
823 };
824
825 static flag_insc_table flag_insc_resistance[] =
826 {
827         { "Ac", TR_RES_ACID, TR_IM_ACID },
828         { "El", TR_RES_ELEC, TR_IM_ELEC },
829         { "Fi", TR_RES_FIRE, TR_IM_FIRE },
830         { "Co", TR_RES_COLD, TR_IM_COLD },
831         { "Po", TR_RES_POIS, -1 },
832         { "Li", TR_RES_LITE, -1 },
833         { "Dk", TR_RES_DARK, -1 },
834         { "Sh", TR_RES_SHARDS, -1 },
835         { "Bl", TR_RES_BLIND, -1 },
836         { "Cf", TR_RES_CONF, -1 },
837         { "So", TR_RES_SOUND, -1 },
838         { "Nt", TR_RES_NETHER, -1 },
839         { "Nx", TR_RES_NEXUS, -1 },
840         { "Ca", TR_RES_CHAOS, -1 },
841         { "Di", TR_RES_DISEN, -1 },
842         { "Fe", TR_RES_FEAR, -1 },
843         { NULL, 0, -1 }
844 };
845
846 static flag_insc_table flag_insc_misc[] =
847 {
848         { "Es", TR_EASY_SPELL, -1 },
849         { "Dm", TR_DEC_MANA, -1 },
850         { "Th", TR_THROW, -1 },
851         { "Rf", TR_REFLECT, -1 },
852         { "Fa", TR_FREE_ACT, -1 },
853         { "Si", TR_SEE_INVIS, -1 },
854         { "Hl", TR_HOLD_LIFE, -1 },
855         { "Sd", TR_SLOW_DIGEST, -1 },
856         { "Rg", TR_REGEN, -1 },
857         { "Lv", TR_LEVITATION, -1 },
858         { "Lu", TR_LITE_1, -1 },
859         { "Lu", TR_LITE_2, -1 },
860         { "Lu", TR_LITE_3, -1 },
861         { "Dl", TR_LITE_M1, -1 },
862         { "Dl", TR_LITE_M2, -1 },
863         { "Dl", TR_LITE_M3, -1 },
864         { "Wr", TR_WARNING, -1 },
865         { "Xm", TR_XTRA_MIGHT, -1 },
866         { "Xs", TR_XTRA_SHOTS, -1 },
867         { "Te", TR_TELEPORT, -1 },
868         { "Ag", TR_AGGRAVATE, -1 },
869         { "Bs", TR_BLESSED, -1 },
870         { "Ty", TR_TY_CURSE, -1 },
871         { "C-", TR_ADD_L_CURSE, -1 },
872         { "C+", TR_ADD_H_CURSE, -1 },
873         { NULL, 0, -1 }
874 };
875
876 static flag_insc_table flag_insc_aura[] =
877 {
878         { "F", TR_SH_FIRE, -1 },
879         { "E", TR_SH_ELEC, -1 },
880         { "C", TR_SH_COLD, -1 },
881         { "M", TR_NO_MAGIC, -1 },
882         { "T", TR_NO_TELE, -1 },
883         { NULL, 0, -1 }
884 };
885
886 static flag_insc_table flag_insc_brand[] =
887 {
888         { "A", TR_BRAND_ACID, -1 },
889         { "E", TR_BRAND_ELEC, -1 },
890         { "F", TR_BRAND_FIRE, -1 },
891         { "Co", TR_BRAND_COLD, -1 },
892         { "P", TR_BRAND_POIS, -1 },
893         { "Ca", TR_CHAOTIC, -1 },
894         { "V", TR_VAMPIRIC, -1 },
895         { "Q", TR_IMPACT, -1 },
896         { "S", TR_VORPAL, -1 },
897         { "M", TR_FORCE_WEAPON, -1 },
898         { NULL, 0, -1 }
899 };
900
901 static flag_insc_table flag_insc_kill[] =
902 {
903         { "*", TR_KILL_EVIL, -1 },
904         { "p", TR_KILL_HUMAN, -1 },
905         { "D", TR_KILL_DRAGON, -1 },
906         { "o", TR_KILL_ORC, -1 },
907         { "T", TR_KILL_TROLL, -1 },
908         { "P", TR_KILL_GIANT, -1 },
909         { "U", TR_KILL_DEMON, -1 },
910         { "L", TR_KILL_UNDEAD, -1 },
911         { "Z", TR_KILL_ANIMAL, -1 },
912         { NULL, 0, -1 }
913 };
914
915 static flag_insc_table flag_insc_slay[] =
916 {
917         { "*", TR_SLAY_EVIL, TR_KILL_EVIL },
918         { "p", TR_SLAY_HUMAN, TR_KILL_HUMAN },
919         { "D", TR_SLAY_DRAGON, TR_KILL_DRAGON },
920         { "o", TR_SLAY_ORC, TR_KILL_ORC },
921         { "T", TR_SLAY_TROLL, TR_KILL_TROLL },
922         { "P", TR_SLAY_GIANT, TR_KILL_GIANT },
923         { "U", TR_SLAY_DEMON, TR_KILL_DEMON },
924         { "L", TR_SLAY_UNDEAD, TR_KILL_UNDEAD },
925         { "Z", TR_SLAY_ANIMAL, TR_KILL_ANIMAL },
926         { NULL, 0, -1 }
927 };
928
929 static flag_insc_table flag_insc_esp1[] =
930 {
931         { "Tele", TR_TELEPATHY, -1 },
932         { "Evil", TR_ESP_EVIL, -1 },
933         { "Good", TR_ESP_GOOD, -1 },
934         { "Nolv", TR_ESP_NONLIVING, -1 },
935         { "Uniq", TR_ESP_UNIQUE, -1 },
936         { NULL, 0, -1 }
937 };
938
939 static flag_insc_table flag_insc_esp2[] =
940 {
941         { "p", TR_ESP_HUMAN, -1 },
942         { "D", TR_ESP_DRAGON, -1 },
943         { "o", TR_ESP_ORC, -1 },
944         { "T", TR_ESP_TROLL, -1 },
945         { "P", TR_ESP_GIANT, -1 },
946         { "U", TR_ESP_DEMON, -1 },
947         { "L", TR_ESP_UNDEAD, -1 },
948         { "Z", TR_ESP_ANIMAL, -1 },
949         { NULL, 0, -1 }
950 };
951
952 static flag_insc_table flag_insc_sust[] =
953 {
954         { "St", TR_SUST_STR, -1 },
955         { "In", TR_SUST_INT, -1 },
956         { "Wi", TR_SUST_WIS, -1 },
957         { "Dx", TR_SUST_DEX, -1 },
958         { "Cn", TR_SUST_CON, -1 },
959         { "Ch", TR_SUST_CHR, -1 },
960         { NULL, 0, -1 }
961 };
962 #endif
963
964 /* ¥ª¥Ö¥¸¥§¥¯¥È¥Õ¥é¥°¤òÄɲ乤뤿¤á¤Î´Ê°×¤Ê¥Þ¥¯¥í / Simple macro for get_inscription() */
965 #define ADD_INSC(STR) (void)(ptr = object_desc_str(ptr, (STR)))
966
967 /*!
968  * @brief get_inscription¤Î¥µ¥Ö¥»¥Ã¥È¤È¤·¤Æ¥ª¥Ö¥¸¥§¥¯¥È¤ÎÆÃÀ­¥Õ¥é¥°¤òÊÖ¤¹ / Helper function for get_inscription()
969  * @param fi_ptr »²¾È¤¹¤ëÆÃÀ­É½¼¨µ­¹æ¥Æ¡¼¥Ö¥ë
970  * @param flgs Âбþ¤¹¤ë¥ª¥Ö¥¸¥§¥¯¥È¤Î¥Õ¥é¥°Ê¸»úÎó
971  * @param kanji TRUE¤Ê¤é¤Ð´Á»úµ­½Ò/FALSE¤Ê¤é¤Ð±Ñ¸ìµ­½Ò
972  * @param ptr ¥Õ¥é¥°·²¤òÊݴɤ¹¤ëʸ»úÎ󻲾ȥݥ¤¥ó¥¿
973  * @return ¥Õ¥é¥°·²¤òÊݴɤ¹¤ëʸ»úÎ󻲾ȥݥ¤¥ó¥¿(ptr¤ÈƱ¤¸)
974  * @details
975  * Print an signed number "v" into a string "t", as if by
976  * sprintf(t, "%+d", n), and return a pointer to the terminator.
977  * Note that we always print a sign, either "+" or "-".
978  */
979 static char *inscribe_flags_aux(flag_insc_table *fi_ptr, u32b flgs[TR_FLAG_SIZE], bool kanji, char *ptr)
980 {
981 #ifndef JP
982         (void)kanji;
983 #endif
984
985         while (fi_ptr->english)
986         {
987                 if (have_flag(flgs, fi_ptr->flag) &&
988                     (fi_ptr->except_flag == -1 || !have_flag(flgs, fi_ptr->except_flag)))
989 #ifdef JP
990                         ADD_INSC(kanji ? fi_ptr->japanese : fi_ptr->english);
991 #else
992                         ADD_INSC(fi_ptr->english);
993 #endif
994                 fi_ptr++;
995         }
996
997         return ptr;
998 }
999
1000
1001 /*!
1002  * @brief ¥ª¥Ö¥¸¥§¥¯¥È¤ÎÆÃÀ­É½¼¨µ­¹æ¥Æ¡¼¥Ö¥ë1¤Ä¤Ë½¾¤¤¥ª¥Ö¥¸¥§¥¯¥È¤ÎÆÃÀ­¥Õ¥é¥°ÇÛÎó¤Ë1¤Ä¤Ç¤â³ºÅö¤ÎÆÃÀ­¤¬¤¢¤ë¤«¤òÊÖ¤¹ / Special variation of have_flag for auto-inscription
1003  * @param fi_ptr »²¾È¤¹¤ëÆÃÀ­É½¼¨µ­¹æ¥Æ¡¼¥Ö¥ë
1004  * @param flgs Âбþ¤¹¤ë¥ª¥Ö¥¸¥§¥¯¥È¤Î¥Õ¥é¥°Ê¸»úÎó
1005  * @return 1¤Ä¤Ç¤â³ºÅö¤ÎÆÃÀ­¤¬¤¢¤Ã¤¿¤éTRUE¤òÊÖ¤¹¡£
1006  */
1007 static bool have_flag_of(flag_insc_table *fi_ptr, u32b flgs[TR_FLAG_SIZE])
1008 {
1009         while (fi_ptr->english)
1010         {
1011                 if (have_flag(flgs, fi_ptr->flag) &&
1012                    (fi_ptr->except_flag == -1 || !have_flag(flgs, fi_ptr->except_flag)))
1013                         return (TRUE);
1014                 fi_ptr++;
1015         }
1016
1017         return (FALSE);
1018 }
1019
1020 /*!
1021  * @brief ¥ª¥Ö¥¸¥§¥¯¥È̾¤ÎÆÃÀ­Ã»½Ìɽµ­¤ò¤Þ¤È¤á¤ÆÄ󼨤¹¤ë¡£
1022  * @param ptr ÆÃÀ­Ã»½Ìɽµ­¤ò³ÊǼ¤¹¤ëʸ»úÎó¥Ý¥¤¥ó¥¿
1023  * @param o_ptr ÆÃÀ­Ã»½Ìɽµ­¤òÆÀ¤¿¤¤¥ª¥Ö¥¸¥§¥¯¥È¹½Â¤ÂΤλ²¾È¥Ý¥¤¥ó¥¿
1024  * @param kanji TRUE¤Ê¤é¤Ð´Á»úɽµ­ / FALSE¤Ê¤é±Ñ¸ìɽµ­
1025  * @param all TRUE¤Ê¤é¤Ð¥Ù¡¼¥¹¥¢¥¤¥Æ¥à¾å¤ÇÌÀ¤é¤«¤Ê¥Õ¥é¥°¤Ï¾Êά¤¹¤ë
1026  * @return ptr¤ÈƱ¤¸¥¢¥É¥ì¥¹
1027  */
1028 static char *get_ability_abbreviation(char *ptr, object_type *o_ptr, bool kanji, bool all)
1029 {
1030         char *prev_ptr = ptr;
1031         u32b flgs[TR_FLAG_SIZE];
1032
1033         /* Extract the flags */
1034         object_flags(o_ptr, flgs);
1035
1036         /* Remove obvious flags */
1037         if (!all)
1038         {
1039                 object_kind *k_ptr = &k_info[o_ptr->k_idx];
1040                 int j;
1041                                 
1042                 /* Base object */
1043                 for (j = 0; j < TR_FLAG_SIZE; j++)
1044                         flgs[j] &= ~k_ptr->flags[j];
1045
1046                 if (object_is_fixed_artifact(o_ptr))
1047                 {
1048                         artifact_type *a_ptr = &a_info[o_ptr->name1];
1049                                         
1050                         for (j = 0; j < TR_FLAG_SIZE; j++)
1051                                 flgs[j] &= ~a_ptr->flags[j];
1052                 }
1053
1054                 if (object_is_ego(o_ptr))
1055                 {
1056                         ego_item_type *e_ptr = &e_info[o_ptr->name2];
1057                                         
1058                         for (j = 0; j < TR_FLAG_SIZE; j++)
1059                                 flgs[j] &= ~e_ptr->flags[j];
1060                 }
1061         }
1062
1063         /* Remove lite flags when this is a dark lite object */
1064         if (have_dark_flag(flgs))
1065         {
1066                 if (have_flag(flgs, TR_LITE_1)) remove_flag(flgs, TR_LITE_1);
1067                 if (have_flag(flgs, TR_LITE_2)) remove_flag(flgs, TR_LITE_2);
1068                 if (have_flag(flgs, TR_LITE_3)) remove_flag(flgs, TR_LITE_3);
1069         }
1070         else if (have_lite_flag(flgs))
1071         {
1072                 add_flag(flgs, TR_LITE_1);
1073                 if (have_flag(flgs, TR_LITE_2)) remove_flag(flgs, TR_LITE_2);
1074                 if (have_flag(flgs, TR_LITE_3)) remove_flag(flgs, TR_LITE_3);
1075         }
1076
1077         /* Plusses */
1078         if (have_flag_of(flag_insc_plus, flgs))
1079         {
1080                 if (kanji)
1081                         ADD_INSC("+");
1082         }
1083         ptr = inscribe_flags_aux(flag_insc_plus, flgs, kanji, ptr);
1084
1085         /* Immunity */
1086         if (have_flag_of(flag_insc_immune, flgs))
1087         {
1088                 if (!kanji && ptr != prev_ptr)
1089                 {
1090                         ADD_INSC(";");
1091                         prev_ptr = ptr;
1092                 }
1093                 ADD_INSC("*");
1094         }
1095         ptr = inscribe_flags_aux(flag_insc_immune, flgs, kanji, ptr);
1096
1097         /* Resistance */
1098         if (have_flag_of(flag_insc_resistance, flgs))
1099         {
1100                 if (kanji)
1101                         ADD_INSC("r");
1102                 else if (ptr != prev_ptr)
1103                 {
1104                         ADD_INSC(";");
1105                         prev_ptr = ptr;
1106                 }
1107         }
1108         ptr = inscribe_flags_aux(flag_insc_resistance, flgs, kanji, ptr);
1109
1110         /* Misc Ability */
1111         if (have_flag_of(flag_insc_misc, flgs))
1112         {
1113                 if (ptr != prev_ptr)
1114                 {
1115                         ADD_INSC(";");
1116                         prev_ptr = ptr;
1117                 }
1118         }
1119         ptr = inscribe_flags_aux(flag_insc_misc, flgs, kanji, ptr);
1120
1121         /* Aura */
1122         if (have_flag_of(flag_insc_aura, flgs))
1123         {
1124                 ADD_INSC("[");
1125         }
1126         ptr = inscribe_flags_aux(flag_insc_aura, flgs, kanji, ptr);
1127
1128         /* Brand Weapon */
1129         if (have_flag_of(flag_insc_brand, flgs))
1130                 ADD_INSC("|");
1131         ptr = inscribe_flags_aux(flag_insc_brand, flgs, kanji, ptr);
1132
1133         /* Kill Weapon */
1134         if (have_flag_of(flag_insc_kill, flgs))
1135                 ADD_INSC("/X");
1136         ptr = inscribe_flags_aux(flag_insc_kill, flgs, kanji, ptr);
1137
1138         /* Slay Weapon */
1139         if (have_flag_of(flag_insc_slay, flgs))
1140                 ADD_INSC("/");
1141         ptr = inscribe_flags_aux(flag_insc_slay, flgs, kanji, ptr);
1142
1143         /* Esp */
1144         if (kanji)
1145         {
1146                 if (have_flag_of(flag_insc_esp1, flgs) ||
1147                     have_flag_of(flag_insc_esp2, flgs))
1148                         ADD_INSC("~");
1149                 ptr = inscribe_flags_aux(flag_insc_esp1, flgs, kanji, ptr);
1150                 ptr = inscribe_flags_aux(flag_insc_esp2, flgs, kanji, ptr);
1151         }
1152         else
1153         {
1154                 if (have_flag_of(flag_insc_esp1, flgs))
1155                         ADD_INSC("~");
1156                 ptr = inscribe_flags_aux(flag_insc_esp1, flgs, kanji, ptr);
1157                 if (have_flag_of(flag_insc_esp2, flgs))
1158                         ADD_INSC("~");
1159                 ptr = inscribe_flags_aux(flag_insc_esp2, flgs, kanji, ptr);
1160         }
1161
1162         /* sustain */
1163         if (have_flag_of(flag_insc_sust, flgs))
1164         {
1165                 ADD_INSC("(");
1166         }
1167         ptr = inscribe_flags_aux(flag_insc_sust, flgs, kanji, ptr);
1168
1169         *ptr = '\0';
1170
1171         return ptr;
1172 }
1173
1174
1175 /*!
1176  * @brief ¥ª¥Ö¥¸¥§¥¯¥È̾¤ÎÆÃÀ­Ã»½Ìɽµ­¡Ü¹ï¤ßÆâÍƤòÄ󼨤¹¤ë¡£ / Get object inscription with auto inscription of object flags.
1177  * @param buff ÆÃÀ­Ã»½Ìɽµ­¤ò³ÊǼ¤¹¤ëʸ»úÎó¥Ý¥¤¥ó¥¿
1178  * @param o_ptr ÆÃÀ­Ã»½Ìɽµ­¤òÆÀ¤¿¤¤¥ª¥Ö¥¸¥§¥¯¥È¹½Â¤ÂΤλ²¾È¥Ý¥¤¥ó¥¿
1179  * @return ¤Ê¤·
1180  */
1181 static void get_inscription(char *buff, object_type *o_ptr)
1182 {
1183         cptr insc = quark_str(o_ptr->inscription);
1184         char *ptr = buff;
1185
1186         /* Not fully identified */
1187         if (!(o_ptr->ident & IDENT_MENTAL))
1188         {
1189                 /* Copy until end of line or '#' */
1190                 while (*insc)
1191                 {
1192                         if (*insc == '#') break;
1193 #ifdef JP
1194                         if (iskanji(*insc)) *buff++ = *insc++;
1195 #endif
1196                         *buff++ = *insc++;
1197                 }
1198
1199                 *buff = '\0';
1200                 return;
1201         }
1202
1203         *buff = '\0';
1204         for (; *insc; insc++)
1205         {
1206                 /* Ignore fake artifact inscription */
1207                 if (*insc == '#') break;
1208
1209                 /* {%} will be automatically converted */
1210                 else if ('%' == *insc)
1211                 {
1212                         bool kanji = FALSE;
1213                         bool all;
1214                         cptr start = ptr;
1215
1216                         /* check for too long inscription */
1217                         if (ptr >= buff + MAX_NLEN) continue;
1218
1219 #ifdef JP
1220                         if ('%' == insc[1])
1221                         {
1222                                 insc++;
1223                                 kanji = FALSE;
1224                         }
1225                         else
1226                         {
1227                                 kanji = TRUE;
1228                         }
1229 #endif
1230                         if ('a' == insc[1] && 'l' == insc[2] && 'l' == insc[3])
1231                         {
1232                                 all = TRUE;
1233                                 insc += 3;
1234                         }
1235                         else
1236                         {
1237                                 all = FALSE;
1238                         }
1239
1240                         ptr = get_ability_abbreviation(ptr, o_ptr, kanji, all);
1241
1242                         if (ptr == start)
1243                                 ADD_INSC(" ");
1244                 }
1245                 else
1246                 {
1247                         *ptr++ = *insc;
1248                 }
1249         }
1250         *ptr = '\0';
1251 }
1252
1253 /*!
1254  * @brief ¥ª¥Ö¥¸¥§¥¯¥È¤¬¥¯¥¨¥¹¥È¤ÎãÀ®ÌÜŪ¤«Èݤ«¤òÊÖ¤¹¡£
1255  * @param o_ptr ÆÃÀ­Ã»½Ìɽµ­¤òÆÀ¤¿¤¤¥ª¥Ö¥¸¥§¥¯¥È¹½Â¤ÂΤλ²¾È¥Ý¥¤¥ó¥¿
1256  * @return ¸½ºß¥¯¥¨¥¹¥ÈãÀ®ÌÜŪ¤Î¥¢¥¤¥Æ¥à¤Ê¤é¤ÐTRUE¤òÊÖ¤¹¡£
1257  */
1258 bool object_is_quest_target(object_type *o_ptr)
1259 {
1260         if (p_ptr->inside_quest)
1261         {
1262                 int a_idx = quest[p_ptr->inside_quest].k_idx;
1263                 if (a_idx)
1264                 {
1265                         artifact_type *a_ptr = &a_info[a_idx];
1266                         if (!(a_ptr->gen_flags & TRG_INSTA_ART))
1267                         {
1268                                 if((o_ptr->tval == a_ptr->tval) && (o_ptr->sval == a_ptr->sval))
1269                                 {
1270                                         return TRUE;
1271                                 }
1272                         }
1273                 }
1274         }
1275         return FALSE;
1276 }
1277
1278
1279 /*!
1280  * @brief ¥ª¥Ö¥¸¥§¥¯¥È¤Î³Æɽµ­¤òÊÖ¤¹¥á¥¤¥ó´Ø¿ô / Creates a description of the item "o_ptr", and stores it in "out_val".
1281  * @param o_ptr ÆÃÀ­Ã»½Ìɽµ­¤òÆÀ¤¿¤¤¥ª¥Ö¥¸¥§¥¯¥È¹½Â¤ÂΤλ²¾È¥Ý¥¤¥ó¥¿
1282  * @return ¸½ºß¥¯¥¨¥¹¥ÈãÀ®ÌÜŪ¤Î¥¢¥¤¥Æ¥à¤Ê¤é¤ÐTRUE¤òÊÖ¤¹¡£
1283  * @details
1284  * One can choose the "verbosity" of the description, including whether\n
1285  * or not the "number" of items should be described, and how much detail\n
1286  * should be used when describing the item.\n
1287  *\n
1288  * The given "buf" must be MAX_NLEN chars long to hold the longest possible\n
1289  * description, which can get pretty long, including incriptions, such as:\n
1290  * "no more Maces of Disruption (Defender) (+10,+10) [+5] (+3 to stealth)".\n
1291  * Note that the inscription will be clipped to keep the total description\n
1292  * under MAX_NLEN-1 chars (plus a terminator).\n
1293  *\n
1294  * Note the use of "object_desc_num()" and "object_desc_int()" as hyper-efficient,\n
1295  * portable, versions of some common "sprintf()" commands.\n
1296  *\n
1297  * Note that all ego-items (when known) append an "Ego-Item Name", unless\n
1298  * the item is also an artifact, which should NEVER happen.\n
1299  *\n
1300  * Note that all artifacts (when known) append an "Artifact Name", so we\n
1301  * have special processing for "Specials" (artifact Lites, Rings, Amulets).\n
1302  * The "Specials" never use "modifiers" if they are "known", since they\n
1303  * have special "descriptions", such as "The Necklace of the Dwarves".\n
1304  *\n
1305  * Special Lite's use the "k_info" base-name (Phial, Star, or Arkenstone),\n
1306  * plus the artifact name, just like any other artifact, if known.\n
1307  *\n
1308  * Special Ring's and Amulet's, if not "aware", use the same code as normal\n
1309  * rings and amulets, and if "aware", use the "k_info" base-name (Ring or\n
1310  * Amulet or Necklace).  They will NEVER "append" the "k_info" name.  But,\n
1311  * they will append the artifact name, just like any artifact, if known.\n
1312  *\n
1313  * Hack -- Display "The One Ring" as "a Plain Gold Ring" until aware.\n
1314  *\n
1315  * Mode:\n
1316  *   OD_NAME_ONLY        : The Cloak of Death\n
1317  *   OD_NAME_AND_ENCHANT : The Cloak of Death [1,+3]\n
1318  *   OD_OMIT_INSCRIPTION : The Cloak of Death [1,+3] (+2 to Stealth)\n
1319  *   0                   : The Cloak of Death [1,+3] (+2 to Stealth) {nifty}\n
1320  *\n
1321  *   OD_OMIT_PREFIX      : Forbidden numeric prefix\n
1322  *   OD_NO_PLURAL        : Forbidden use of plural \n
1323  *   OD_STORE            : Assume to be aware and known\n
1324  *   OD_NO_FLAVOR        : Allow to hidden flavor\n
1325  *   OD_FORCE_FLAVOR     : Get un-shuffled flavor name\n
1326  */
1327 void object_desc(char *buf, object_type *o_ptr, u32b mode)
1328 {
1329         /* Extract object kind name */
1330         cptr            kindname = k_name + k_info[o_ptr->k_idx].name;
1331
1332         /* Extract default "base" string */
1333         cptr            basenm = kindname;
1334
1335         /* Assume no "modifier" string */
1336         cptr            modstr = "";
1337
1338         int             power;
1339         int                             fire_rate;
1340
1341         bool            aware = FALSE;
1342         bool            known = FALSE;
1343         bool            flavor = TRUE;
1344
1345         bool            show_weapon = FALSE;
1346         bool            show_armour = FALSE;
1347
1348         cptr            s, s0;
1349         char            *t;
1350
1351         char            p1 = '(', p2 = ')';
1352         char            b1 = '[', b2 = ']';
1353         char            c1 = '{', c2 = '}';
1354
1355         char            tmp_val[MAX_NLEN+160];
1356         char            tmp_val2[MAX_NLEN+10];
1357         char            fake_insc_buf[30];
1358
1359         u32b flgs[TR_FLAG_SIZE];
1360
1361         object_type *bow_ptr;
1362
1363         object_kind *k_ptr = &k_info[o_ptr->k_idx];
1364         object_kind *flavor_k_ptr = &k_info[k_ptr->flavor];
1365
1366         /* Extract some flags */
1367         object_flags(o_ptr, flgs);
1368
1369         /* See if the object is "aware" */
1370         if (object_is_aware(o_ptr)) aware = TRUE;
1371
1372         /* See if the object is "known" */
1373         if (object_is_known(o_ptr)) known = TRUE;
1374
1375         /* Allow flavors to be hidden when aware */
1376         if (aware && ((mode & OD_NO_FLAVOR) || plain_descriptions)) flavor = FALSE;
1377
1378         /* Object is in the inventory of a store or spoiler */
1379         if ((mode & OD_STORE) || (o_ptr->ident & IDENT_STORE))
1380         {
1381                 /* Don't show flavors */
1382                 flavor = FALSE;
1383
1384                 /* Pretend known and aware */
1385                 aware = TRUE;
1386                 known = TRUE;
1387         }
1388
1389         /* Force to be flavor name only */
1390         if (mode & OD_FORCE_FLAVOR)
1391         {
1392                 aware = FALSE;
1393                 flavor = TRUE;
1394                 known = FALSE;
1395
1396                 /* Cancel shuffling */
1397                 flavor_k_ptr = k_ptr;
1398         }
1399
1400         /* Analyze the object */
1401         switch (o_ptr->tval)
1402         {
1403                 /* Some objects are easy to describe */
1404                 case TV_SKELETON:
1405                 case TV_BOTTLE:
1406                 case TV_JUNK:
1407                 case TV_SPIKE:
1408                 case TV_FLASK:
1409                 case TV_CHEST:
1410                 case TV_WHISTLE:
1411                 {
1412                         break;
1413                 }
1414
1415                 case TV_CAPTURE:
1416                 {
1417                         monster_race *r_ptr = &r_info[o_ptr->pval];
1418
1419                         if (known)
1420                         {
1421                                 if (!o_ptr->pval)
1422                                 {
1423 #ifdef JP
1424                                         modstr = " (¶õ)";
1425 #else
1426                                         modstr = " (empty)";
1427 #endif
1428                                 }
1429                                 else
1430                                 {
1431 #ifdef JP
1432                                         sprintf(tmp_val2, " (%s)",r_name + r_ptr->name);
1433                                         modstr = tmp_val2;
1434 #else
1435                                         cptr t = r_name + r_ptr->name;
1436
1437                                         if (!(r_ptr->flags1 & RF1_UNIQUE))
1438                                         {
1439                                                 sprintf(tmp_val2, " (%s%s)", (is_a_vowel(*t) ? "an " : "a "), t);
1440
1441                                                 modstr = tmp_val2;
1442                                         }
1443                                         else
1444                                         {
1445                                                 sprintf(tmp_val2, "(%s)", t);
1446
1447                                                 modstr = t;
1448                                         }
1449 #endif
1450                                 }
1451                         }
1452                         break;
1453                 }
1454
1455                 /* Figurines/Statues */
1456                 case TV_FIGURINE:
1457                 case TV_STATUE:
1458                 {
1459                         monster_race *r_ptr = &r_info[o_ptr->pval];
1460
1461 #ifdef JP
1462                         modstr = r_name + r_ptr->name;
1463 #else
1464                         cptr t = r_name + r_ptr->name;
1465
1466                         if (!(r_ptr->flags1 & RF1_UNIQUE))
1467                         {
1468                                 sprintf(tmp_val2, "%s%s", (is_a_vowel(*t) ? "an " : "a "), t);
1469
1470                                 modstr = tmp_val2;
1471                         }
1472                         else
1473                         {
1474                                 modstr = t;
1475                         }
1476 #endif
1477
1478
1479                         break;
1480                 }
1481
1482                 /* Corpses */
1483                 case TV_CORPSE:
1484                 {
1485                         monster_race *r_ptr = &r_info[o_ptr->pval];
1486
1487                         modstr = r_name + r_ptr->name;
1488
1489 #ifdef JP
1490                         basenm = "#%";
1491 #else
1492                         if (r_ptr->flags1 & RF1_UNIQUE)
1493                                 basenm = "& % of #";
1494                         else
1495                                 basenm = "& # %";
1496 #endif
1497
1498                         break;
1499                 }
1500
1501                 /* Missiles/ Bows/ Weapons */
1502                 case TV_SHOT:
1503                 case TV_BOLT:
1504                 case TV_ARROW:
1505                 case TV_BOW:
1506                 case TV_HAFTED:
1507                 case TV_POLEARM:
1508                 case TV_SWORD:
1509                 case TV_DIGGING:
1510                 {
1511                         show_weapon = TRUE;
1512                         break;
1513                 }
1514
1515                 /* Armour */
1516                 case TV_BOOTS:
1517                 case TV_GLOVES:
1518                 case TV_CLOAK:
1519                 case TV_CROWN:
1520                 case TV_HELM:
1521                 case TV_SHIELD:
1522                 case TV_SOFT_ARMOR:
1523                 case TV_HARD_ARMOR:
1524                 case TV_DRAG_ARMOR:
1525                 {
1526                         show_armour = TRUE;
1527                         break;
1528                 }
1529
1530                 /* Lites (including a few "Specials") */
1531                 case TV_LITE:
1532                 {
1533                         break;
1534                 }
1535
1536                 /* Amulets (including a few "Specials") */
1537                 case TV_AMULET:
1538                 {
1539                         /* Known artifacts */
1540                         if (aware)
1541                         {
1542                                 if (object_is_fixed_artifact(o_ptr)) break;
1543                                 if (k_ptr->gen_flags & TRG_INSTA_ART) break;
1544                         }
1545
1546                         /* Color the object */
1547                         modstr = k_name + flavor_k_ptr->flavor_name;
1548
1549 #ifdef JP
1550                         if (!flavor)    basenm = "%¤Î¥¢¥ß¥å¥ì¥Ã¥È";
1551                         else if (aware) basenm = "%¤Î#¥¢¥ß¥å¥ì¥Ã¥È";
1552                         else            basenm = "#¥¢¥ß¥å¥ì¥Ã¥È";
1553 #else
1554                         if (!flavor)    basenm = "& Amulet~ of %";
1555                         else if (aware) basenm = "& # Amulet~ of %";
1556                         else            basenm = "& # Amulet~";
1557 #endif
1558
1559                         break;
1560                 }
1561
1562                 /* Rings (including a few "Specials") */
1563                 case TV_RING:
1564                 {
1565                         /* Known artifacts */
1566                         if (aware)
1567                         {
1568                                 if (object_is_fixed_artifact(o_ptr)) break;
1569                                 if (k_ptr->gen_flags & TRG_INSTA_ART) break;
1570                         }
1571
1572                         /* Color the object */
1573                         modstr = k_name + flavor_k_ptr->flavor_name;
1574
1575 #ifdef JP
1576                         if (!flavor)    basenm = "%¤Î»ØÎØ";
1577                         else if (aware) basenm = "%¤Î#»ØÎØ";
1578                         else            basenm = "#»ØÎØ";
1579 #else
1580                         if (!flavor)    basenm = "& Ring~ of %";
1581                         else if (aware) basenm = "& # Ring~ of %";
1582                         else            basenm = "& # Ring~";
1583 #endif
1584
1585                         if (!k_ptr->to_h && !k_ptr->to_d && (o_ptr->to_h || o_ptr->to_d)) show_weapon = TRUE;
1586
1587                         break;
1588                 }
1589
1590                 case TV_CARD:
1591                 {
1592                         break;
1593                 }
1594
1595                 case TV_STAFF:
1596                 {
1597                         /* Color the object */
1598                         modstr = k_name + flavor_k_ptr->flavor_name;
1599
1600 #ifdef JP
1601                         if (!flavor)    basenm = "%¤Î¾ó";
1602                         else if (aware) basenm = "%¤Î#¾ó";
1603                         else            basenm = "#¾ó";
1604 #else
1605                         if (!flavor)    basenm = "& Staff~ of %";
1606                         else if (aware) basenm = "& # Staff~ of %";
1607                         else            basenm = "& # Staff~";
1608 #endif
1609
1610                         break;
1611                 }
1612
1613                 case TV_WAND:
1614                 {
1615                         /* Color the object */
1616                         modstr = k_name + flavor_k_ptr->flavor_name;
1617
1618 #ifdef JP
1619                         if (!flavor)    basenm = "%¤ÎËâË¡ËÀ";
1620                         else if (aware) basenm = "%¤Î#ËâË¡ËÀ";
1621                         else            basenm = "#ËâË¡ËÀ";
1622 #else
1623                         if (!flavor)    basenm = "& Wand~ of %";
1624                         else if (aware) basenm = "& # Wand~ of %";
1625                         else            basenm = "& # Wand~";
1626 #endif
1627
1628                         break;
1629                 }
1630
1631                 case TV_ROD:
1632                 {
1633                         /* Color the object */
1634                         modstr = k_name + flavor_k_ptr->flavor_name;
1635
1636 #ifdef JP
1637                         if (!flavor)    basenm = "%¤Î¥í¥Ã¥É";
1638                         else if (aware) basenm = "%¤Î#¥í¥Ã¥É";
1639                         else            basenm = "#¥í¥Ã¥É";
1640 #else
1641                         if (!flavor)    basenm = "& Rod~ of %";
1642                         else if (aware) basenm = "& # Rod~ of %";
1643                         else            basenm = "& # Rod~";
1644 #endif
1645
1646                         break;
1647                 }
1648
1649                 case TV_SCROLL:
1650                 {
1651                         /* Color the object */
1652                         modstr = k_name + flavor_k_ptr->flavor_name;
1653
1654 #ifdef JP
1655                         if (!flavor)    basenm = "%¤Î´¬Êª";
1656                         else if (aware) basenm = "¡Ö#¡×¤È½ñ¤«¤ì¤¿%¤Î´¬Êª";
1657                         else            basenm = "¡Ö#¡×¤È½ñ¤«¤ì¤¿´¬Êª";
1658 #else
1659                         if (!flavor)    basenm = "& Scroll~ of %";
1660                         else if (aware) basenm = "& Scroll~ titled \"#\" of %";
1661                         else            basenm = "& Scroll~ titled \"#\"";
1662 #endif
1663
1664                         break;
1665                 }
1666
1667                 case TV_POTION:
1668                 {
1669                         /* Color the object */
1670                         modstr = k_name + flavor_k_ptr->flavor_name;
1671
1672 #ifdef JP
1673                         if (!flavor)    basenm = "%¤ÎÌô";
1674                         else if (aware) basenm = "%¤Î#Ìô";
1675                         else            basenm = "#Ìô";
1676 #else
1677                         if (!flavor)    basenm = "& Potion~ of %";
1678                         else if (aware) basenm = "& # Potion~ of %";
1679                         else            basenm = "& # Potion~";
1680 #endif
1681
1682                         break;
1683                 }
1684
1685                 case TV_FOOD:
1686                 {
1687                         /* Ordinary food is "boring" */
1688                         if (!k_ptr->flavor_name) break;
1689
1690                         /* Color the object */
1691                         modstr = k_name + flavor_k_ptr->flavor_name;
1692
1693 #ifdef JP
1694                         if (!flavor)    basenm = "%¤Î¥­¥Î¥³";
1695                         else if (aware) basenm = "%¤Î#¥­¥Î¥³";
1696                         else            basenm = "#¥­¥Î¥³";
1697 #else
1698                         if (!flavor)    basenm = "& Mushroom~ of %";
1699                         else if (aware) basenm = "& # Mushroom~ of %";
1700                         else            basenm = "& # Mushroom~";
1701 #endif
1702
1703                         break;
1704                 }
1705
1706                 case TV_PARCHMENT:
1707                 {
1708 #ifdef JP
1709                         basenm = "ÍÓÈé»æ - %";
1710 #else
1711                         basenm = "& Parchment~ - %";
1712 #endif
1713                         break;
1714                 }
1715
1716                 /* Magic Books */
1717                 case TV_LIFE_BOOK:
1718                 {
1719 #ifdef JP
1720                         basenm = "À¸Ì¿¤ÎËâË¡½ñ%";
1721 #else
1722                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1723                                 basenm = "& Book~ of Life Magic %";
1724                         else
1725                                 basenm = "& Life Spellbook~ %";
1726 #endif
1727
1728                         break;
1729                 }
1730
1731                 case TV_SORCERY_BOOK:
1732                 {
1733 #ifdef JP
1734                         basenm = "Àç½Ñ¤ÎËâË¡½ñ%";
1735 #else
1736                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1737                                 basenm = "& Book~ of Sorcery %";
1738                         else
1739                                 basenm = "& Sorcery Spellbook~ %";
1740 #endif
1741
1742                         break;
1743                 }
1744
1745                 case TV_NATURE_BOOK:
1746                 {
1747 #ifdef JP
1748                         basenm = "¼«Á³¤ÎËâË¡½ñ%";
1749 #else
1750                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1751                                 basenm = "& Book~ of Nature Magic %";
1752                         else
1753                                 basenm = "& Nature Spellbook~ %";
1754 #endif
1755
1756                         break;
1757                 }
1758
1759                 case TV_CHAOS_BOOK:
1760                 {
1761 #ifdef JP
1762                         basenm = "¥«¥ª¥¹¤ÎËâË¡½ñ%";
1763 #else
1764                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1765                                 basenm = "& Book~ of Chaos Magic %";
1766                         else
1767                                 basenm = "& Chaos Spellbook~ %";
1768 #endif
1769
1770                         break;
1771                 }
1772
1773                 case TV_DEATH_BOOK:
1774                 {
1775 #ifdef JP
1776                         basenm = "°Å¹õ¤ÎËâË¡½ñ%";
1777 #else
1778                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1779                                 basenm = "& Book~ of Death Magic %";
1780                         else
1781                                 basenm = "& Death Spellbook~ %";
1782 #endif
1783
1784                         break;
1785                 }
1786
1787                 case TV_TRUMP_BOOK:
1788                 {
1789 #ifdef JP
1790                         basenm = "¥È¥é¥ó¥×¤ÎËâË¡½ñ%";
1791 #else
1792                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1793                                 basenm = "& Book~ of Trump Magic %";
1794                         else
1795                                 basenm = "& Trump Spellbook~ %";
1796 #endif
1797
1798                         break;
1799                 }
1800
1801                 case TV_ARCANE_BOOK:
1802                 {
1803 #ifdef JP
1804                         basenm = "Èë½Ñ¤ÎËâË¡½ñ%";
1805 #else
1806                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1807                                 basenm = "& Book~ of Arcane Magic %";
1808                         else
1809                                 basenm = "& Arcane Spellbook~ %";
1810 #endif
1811
1812                         break;
1813                 }
1814
1815                 case TV_CRAFT_BOOK:
1816                 {
1817 #ifdef JP
1818                         basenm = "¾¢¤ÎËâË¡½ñ%";
1819 #else
1820                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1821                                 basenm = "& Book~ of Craft Magic %";
1822                         else
1823                                 basenm = "& Craft Spellbook~ %";
1824 #endif
1825
1826                         break;
1827                 }
1828
1829                 case TV_DAEMON_BOOK:
1830                 {
1831 #ifdef JP
1832                         basenm = "°­Ëâ¤ÎËâË¡½ñ%";
1833 #else
1834                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1835                                 basenm = "& Book~ of Daemon Magic %";
1836                         else
1837                                 basenm = "& Daemon Spellbook~ %";
1838 #endif
1839
1840                         break;
1841                 }
1842
1843                 case TV_CRUSADE_BOOK:
1844                 {
1845 #ifdef JP
1846                         basenm = "Ç˼٤ÎËâË¡½ñ%";
1847 #else
1848                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1849                                 basenm = "& Book~ of Crusade Magic %";
1850                         else
1851                                 basenm = "& Crusade Spellbook~ %";
1852 #endif
1853
1854                         break;
1855                 }
1856
1857                 case TV_MUSIC_BOOK:
1858                 {
1859 #ifdef JP
1860                         basenm = "²Î½¸%";
1861 #else
1862                         basenm = "& Song Book~ %";
1863 #endif
1864
1865                         break;
1866                 }
1867
1868                 case TV_HISSATSU_BOOK:
1869                 {
1870 #ifdef JP
1871                         basenm = "& Éð·Ý¤Î½ñ%";
1872 #else
1873                         basenm = "Book~ of Kendo %";
1874 #endif
1875
1876                         break;
1877                 }
1878
1879                 case TV_HEX_BOOK:
1880                 {
1881 #ifdef JP
1882                         basenm = "¼ö½Ñ¤ÎËâË¡½ñ%";
1883 #else
1884                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1885                                 basenm = "& Book~ of Hex Magic %";
1886                         else
1887                                 basenm = "& Hex Spellbook~ %";
1888 #endif
1889
1890                         break;
1891                 }
1892
1893                 /* Hack -- Gold/Gems */
1894                 case TV_GOLD:
1895                 {
1896                         strcpy(buf, basenm);
1897                         return;
1898                 }
1899
1900                 /* Used in the "inventory" routine */
1901                 default:
1902                 {
1903 #ifdef JP
1904                         strcpy(buf, "(¤Ê¤·)");
1905 #else
1906                         strcpy(buf, "(nothing)");
1907 #endif
1908
1909                         return;
1910                 }
1911         }
1912
1913         /* Use full name from k_info or a_info */
1914         if (aware && have_flag(flgs, TR_FULL_NAME))
1915         {
1916                 if (known && o_ptr->name1) basenm = a_name + a_info[o_ptr->name1].name;
1917                 else basenm = kindname;
1918         }
1919
1920         /* Start dumping the result */
1921         t = tmp_val;
1922
1923 #ifdef JP
1924         if (basenm[0] == '&')
1925                 s = basenm + 2;
1926         else
1927                 s = basenm;
1928
1929         /* No prefix */
1930         if (mode & OD_OMIT_PREFIX)
1931         {
1932                 /* Nothing */
1933         }
1934         else if (o_ptr->number > 1)
1935         {
1936                 t = object_desc_kosuu(t, o_ptr);
1937                 t = object_desc_str(t, "¤Î ");
1938         }
1939
1940         /* ±Ñ¸ì¤Î¾ì¹ç¥¢¡¼¥Æ¥£¥Õ¥¡¥¯¥È¤Ï The ¤¬ÉÕ¤¯¤Î¤Çʬ¤«¤ë¤¬
1941          * ÆüËܸì¤Ç¤Ïʬ¤«¤é¤Ê¤¤¤Î¤Ç¥Þ¡¼¥¯¤ò¤Ä¤±¤ë 
1942          */
1943         if (known)
1944         {
1945                 if (object_is_fixed_artifact(o_ptr)) t = object_desc_str(t, "¡ú");
1946                 else if (o_ptr->art_name) t = object_desc_str(t, "¡ù");
1947         }
1948
1949 #else
1950
1951         /* The object "expects" a "number" */
1952         if (basenm[0] == '&')
1953         {
1954                 /* Skip the ampersand (and space) */
1955                 s = basenm + 2;
1956
1957                 /* No prefix */
1958                 if (mode & OD_OMIT_PREFIX)
1959                 {
1960                         /* Nothing */
1961                 }
1962
1963                 /* Hack -- None left */
1964                 else if (o_ptr->number <= 0)
1965                 {
1966                         t = object_desc_str(t, "no more ");
1967                 }
1968
1969                 /* Extract the number */
1970                 else if (o_ptr->number > 1)
1971                 {
1972                         t = object_desc_num(t, o_ptr->number);
1973                         t = object_desc_chr(t, ' ');
1974                 }
1975
1976                 /* Hack -- The only one of its kind */
1977                 else if ((known && object_is_artifact(o_ptr)) ||
1978                          ((o_ptr->tval == TV_CORPSE) &&
1979                           (r_info[o_ptr->pval].flags1 & RF1_UNIQUE)))
1980                 {
1981                         t = object_desc_str(t, "The ");
1982                 }
1983
1984                 /* A single one */
1985                 else
1986                 {
1987                         bool vowel;
1988
1989                         switch (*s)
1990                         {
1991                         case '#': vowel = is_a_vowel(modstr[0]); break;
1992                         case '%': vowel = is_a_vowel(*kindname); break;
1993                         default:  vowel = is_a_vowel(*s); break;
1994                         }
1995
1996                         if (vowel)
1997                         {
1998                                 /* A single one, with a vowel */
1999                                 t = object_desc_str(t, "an ");
2000                         }
2001                         else
2002                         {
2003                                 /* A single one, without a vowel */
2004                                 t = object_desc_str(t, "a ");
2005                         }
2006                 }
2007         }
2008
2009         /* Hack -- objects that "never" take an article */
2010         else
2011         {
2012                 /* No ampersand */
2013                 s = basenm;
2014
2015                 /* No pref */
2016                 if (mode & OD_OMIT_PREFIX)
2017                 {
2018                         /* Nothing */
2019                 }
2020
2021                 /* Hack -- all gone */
2022                 else if (o_ptr->number <= 0)
2023                 {
2024                         t = object_desc_str(t, "no more ");
2025                 }
2026
2027                 /* Prefix a number if required */
2028                 else if (o_ptr->number > 1)
2029                 {
2030                         t = object_desc_num(t, o_ptr->number);
2031                         t = object_desc_chr(t, ' ');
2032                 }
2033
2034                 /* Hack -- The only one of its kind */
2035                 else if (known && object_is_artifact(o_ptr))
2036                 {
2037                         t = object_desc_str(t, "The ");
2038                 }
2039
2040                 /* Hack -- single items get no prefix */
2041                 else
2042                 {
2043                         /* Nothing */
2044                 }
2045         }
2046 #endif
2047
2048         /* Paranoia -- skip illegal tildes */
2049         /* while (*s == '~') s++; */
2050
2051 #ifdef JP
2052         if (object_is_smith(o_ptr))
2053         {
2054                 t = object_desc_str(t, format("ÃÃÌê»Õ%s¤Î", player_name));
2055         }
2056
2057         /* ÅÁÀâ¤Î¥¢¥¤¥Æ¥à¡¢Ì¾¤Î¤¢¤ë¥¢¥¤¥Æ¥à¤Î̾Á°¤òÉղ乤ë */
2058         if (known)
2059         {
2060                 /* ¥é¥ó¥À¥à¡¦¥¢¡¼¥Æ¥£¥Õ¥¡¥¯¥È */
2061                 if (o_ptr->art_name)
2062                 {
2063                         cptr temp = quark_str(o_ptr->art_name);
2064
2065                         /* '¡Ø' ¤«¤é»Ï¤Þ¤é¤Ê¤¤ÅÁÀâ¤Î¥¢¥¤¥Æ¥à¤Î̾Á°¤ÏºÇ½é¤ËÉղ乤ë */
2066                         /* ±Ñ¸ìÈǤΥ»¡¼¥Ö¥Õ¥¡¥¤¥ë¤«¤éÍ褿 'of XXX' ¤Ï,¡ÖXXX¤Î¡×¤Èɽ¼¨¤¹¤ë */
2067                         if (strncmp(temp, "of ", 3) == 0)
2068                         {
2069                                 t = object_desc_str(t, &temp[3]);
2070                                 t = object_desc_str(t, "¤Î");
2071                         }
2072                         else if ((strncmp(temp, "¡Ø", 2) != 0) &&
2073                                  (strncmp(temp, "¡Ô", 2) != 0) &&
2074                                  (temp[0] != '\''))
2075                                 t = object_desc_str(t, temp);
2076                 }
2077                 /* ÅÁÀâ¤Î¥¢¥¤¥Æ¥à */
2078                 else if (o_ptr->name1 && !have_flag(flgs, TR_FULL_NAME))
2079                 {
2080                         artifact_type *a_ptr = &a_info[o_ptr->name1];
2081                         /* '¡Ø' ¤«¤é»Ï¤Þ¤é¤Ê¤¤ÅÁÀâ¤Î¥¢¥¤¥Æ¥à¤Î̾Á°¤ÏºÇ½é¤ËÉղ乤ë */
2082                         if (strncmp(a_name + a_ptr->name, "¡Ø", 2) != 0)
2083                         {
2084                                 t = object_desc_str(t, a_name + a_ptr->name);
2085                         }
2086                 }
2087                 /* Ì¾¤Î¤¢¤ë¥¢¥¤¥Æ¥à */
2088                 else if (object_is_ego(o_ptr))
2089                 {
2090                         ego_item_type *e_ptr = &e_info[o_ptr->name2];
2091                         t = object_desc_str(t, e_name + e_ptr->name);
2092                 }
2093         }
2094 #endif
2095
2096         /* Copy the string */
2097         for (s0 = NULL; *s || s0; )
2098         {
2099                 /* The end of the flavour/kind string. */
2100                 if (!*s)
2101                 {
2102                         s = s0 + 1;
2103                         s0 = NULL;
2104                 }
2105
2106                 /* Begin to append the modifier (flavor) */
2107                 else if ((*s == '#') && !s0)
2108                 {
2109                         s0 = s;
2110                         s = modstr;
2111
2112                         /* Paranoia -- Never append multiple modstrs */
2113                         modstr = "";
2114                 }
2115
2116                 /* Begin to append the kind name */
2117                 else if ((*s == '%') && !s0)
2118                 {
2119                         s0 = s;
2120                         s = kindname;
2121
2122                         /* Paranoia -- Never append multiple kindnames */
2123                         kindname = "";
2124                 }
2125
2126 #ifndef JP
2127                 /* Pluralizer */
2128                 else if (*s == '~')
2129                 {
2130                         /* Add a plural if needed */
2131                         if (!(mode & OD_NO_PLURAL) && (o_ptr->number != 1))
2132                         {
2133                                 char k = t[-1];
2134
2135                                 /* XXX XXX XXX Mega-Hack */
2136
2137                                 /* Hack -- "Cutlass-es" and "Torch-es" */
2138                                 if ((k == 's') || (k == 'h')) *t++ = 'e';
2139
2140                                 /* Add an 's' */
2141                                 *t++ = 's';
2142                         }
2143                         s++;
2144                 }
2145 #endif
2146
2147                 /* Normal */
2148                 else
2149                 {
2150                         /* Copy */
2151                         *t++ = *s++;
2152                 }
2153         }
2154
2155         /* Terminate */
2156         *t = '\0';
2157
2158
2159 #ifdef JP
2160         /* '¡Ø'¤«¤é»Ï¤Þ¤ëÅÁÀâ¤Î¥¢¥¤¥Æ¥à¤Î̾Á°¤ÏºÇ¸å¤ËÉղ乤ë */
2161         if (known)
2162         {
2163                 /* ¥é¥ó¥À¥à¥¢¡¼¥Æ¥£¥Õ¥¡¥¯¥È¤Î̾Á°¤Ï¥»¡¼¥Ö¥Õ¥¡¥¤¥ë¤Ëµ­Ï¿
2164                    ¤µ¤ì¤ë¤Î¤Ç¡¢±Ñ¸ìÈǤÎ̾Á°¤â¤½¤ì¤é¤·¤¯ÊÑ´¹¤¹¤ë */
2165                 if (o_ptr->art_name)
2166                 {
2167                         char temp[256];
2168                         int itemp;
2169                         strcpy(temp, quark_str(o_ptr->art_name));
2170                         /* MEGA HACK by ita */
2171                         if (strncmp(temp, "¡Ø", 2) == 0 ||
2172                             strncmp(temp, "¡Ô", 2) == 0)
2173                                 t = object_desc_str(t, temp);
2174                         else if (temp[0] == '\'')
2175                         {
2176                                 itemp = strlen(temp);
2177                                 temp[itemp - 1] = 0;
2178                                 t = object_desc_str(t, "¡Ø");
2179                                 t = object_desc_str(t, &temp[1]);
2180                                 t = object_desc_str(t, "¡Ù");
2181                         }
2182                 }
2183                 else if (object_is_fixed_artifact(o_ptr))
2184                 {
2185                         artifact_type *a_ptr = &a_info[o_ptr->name1];
2186                         if (strncmp(a_name + a_ptr->name, "¡Ø", 2) == 0)
2187                         {
2188                                 t = object_desc_str(t, a_name + a_ptr->name);
2189                         }
2190                 }
2191                 else if (o_ptr->inscription)
2192                 {
2193                         cptr str = quark_str(o_ptr->inscription);
2194
2195                         while(*str)
2196                         {
2197                                 if (iskanji(*str))
2198                                 {
2199                                         str += 2;
2200                                         continue;
2201                                 }
2202                                 if (*str == '#') break;
2203                                 str++;
2204                         }
2205                         if (*str)
2206                         {
2207                                 /* Find the '#' */
2208                                 cptr str = my_strchr(quark_str(o_ptr->inscription), '#');
2209
2210                                 /* Add the false name */
2211                                 t = object_desc_str(t,"¡Ø");
2212                                 t = object_desc_str(t, &str[1]);
2213                                 t = object_desc_str(t,"¡Ù");
2214                         }
2215                 }
2216         }
2217 #else
2218         if (object_is_smith(o_ptr))
2219         {
2220                 t = object_desc_str(t,format(" of %s the Smith",player_name));
2221         }
2222
2223         /* Hack -- Append "Artifact" or "Special" names */
2224         if (known && !have_flag(flgs, TR_FULL_NAME))
2225         {
2226                 /* Is it a new random artifact ? */
2227                 if (o_ptr->art_name)
2228                 {
2229                         t = object_desc_chr(t, ' ');
2230                         t = object_desc_str(t, quark_str(o_ptr->art_name));
2231                 }
2232
2233                 /* Grab any artifact name */
2234                 else if (object_is_fixed_artifact(o_ptr))
2235                 {
2236                         artifact_type *a_ptr = &a_info[o_ptr->name1];
2237
2238                         t = object_desc_chr(t, ' ');
2239                         t = object_desc_str(t, a_name + a_ptr->name);
2240                 }
2241
2242                 /* Grab any ego-item name */
2243                 else
2244                 {
2245                         if (object_is_ego(o_ptr))
2246                         {
2247                                 ego_item_type *e_ptr = &e_info[o_ptr->name2];
2248
2249                                 t = object_desc_chr(t, ' ');
2250                                 t = object_desc_str(t, e_name + e_ptr->name);
2251                         }
2252
2253                         if (o_ptr->inscription && my_strchr(quark_str(o_ptr->inscription), '#'))
2254                         {
2255                                 /* Find the '#' */
2256                                 cptr str = my_strchr(quark_str(o_ptr->inscription), '#');
2257
2258                                 /* Add the false name */
2259                                 t = object_desc_chr(t, ' ');
2260                                 t = object_desc_str(t, &str[1]);
2261                         }
2262                 }
2263         }
2264 #endif
2265
2266
2267         /* No more details wanted */
2268         if (mode & OD_NAME_ONLY) goto object_desc_done;
2269
2270         /* Hack -- Chests must be described in detail */
2271         if (o_ptr->tval == TV_CHEST)
2272         {
2273                 /* Not searched yet */
2274                 if (!known)
2275                 {
2276                         /* Nothing */
2277                 }
2278
2279                 /* May be "empty" */
2280                 else if (!o_ptr->pval)
2281                 {
2282 #ifdef JP
2283                         t = object_desc_str(t, "(¶õ)");
2284 #else
2285                         t = object_desc_str(t, " (empty)");
2286 #endif
2287                 }
2288
2289                 /* May be "disarmed" */
2290                 else if (o_ptr->pval < 0)
2291                 {
2292                         if (chest_traps[0 - o_ptr->pval])
2293                         {
2294 #ifdef JP
2295                                 t = object_desc_str(t, "(²ò½üºÑ)");
2296 #else
2297                                 t = object_desc_str(t, " (disarmed)");
2298 #endif
2299                         }
2300                         else
2301                         {
2302 #ifdef JP
2303                                 t = object_desc_str(t, "(Èó»Ü¾û)");
2304 #else
2305                                 t = object_desc_str(t, " (unlocked)");
2306 #endif
2307                         }
2308                 }
2309
2310                 /* Describe the traps, if any */
2311                 else
2312                 {
2313                         /* Describe the traps */
2314                         switch (chest_traps[o_ptr->pval])
2315                         {
2316                                 case 0:
2317                                 {
2318 #ifdef JP
2319                                         t = object_desc_str(t, "(»Ü¾û)");
2320 #else
2321                                         t = object_desc_str(t, " (Locked)");
2322 #endif
2323                                         break;
2324                                 }
2325                                 case CHEST_LOSE_STR:
2326                                 {
2327 #ifdef JP
2328                                         t = object_desc_str(t, "(ÆÇ¿Ë)");
2329 #else
2330                                         t = object_desc_str(t, " (Poison Needle)");
2331 #endif
2332                                         break;
2333                                 }
2334                                 case CHEST_LOSE_CON:
2335                                 {
2336 #ifdef JP
2337                                         t = object_desc_str(t, "(ÆÇ¿Ë)");
2338 #else
2339                                         t = object_desc_str(t, " (Poison Needle)");
2340 #endif
2341                                         break;
2342                                 }
2343                                 case CHEST_POISON:
2344                                 {
2345 #ifdef JP
2346                                         t = object_desc_str(t, "(¥¬¥¹¡¦¥È¥é¥Ã¥×)");
2347 #else
2348                                         t = object_desc_str(t, " (Gas Trap)");
2349 #endif
2350                                         break;
2351                                 }
2352                                 case CHEST_PARALYZE:
2353                                 {
2354 #ifdef JP
2355                                         t = object_desc_str(t, "(¥¬¥¹¡¦¥È¥é¥Ã¥×)");
2356 #else
2357                                         t = object_desc_str(t, " (Gas Trap)");
2358 #endif
2359                                         break;
2360                                 }
2361                                 case CHEST_EXPLODE:
2362                                 {
2363 #ifdef JP
2364                                         t = object_desc_str(t, "(ÇúȯÁõÃÖ)");
2365 #else
2366                                         t = object_desc_str(t, " (Explosion Device)");
2367 #endif
2368                                         break;
2369                                 }
2370                                 case CHEST_SUMMON:
2371                                 case CHEST_BIRD_STORM:
2372                                 case CHEST_E_SUMMON:
2373                                 case CHEST_H_SUMMON:
2374                                 {
2375 #ifdef JP
2376                                         t = object_desc_str(t, "(¾¤´­¤Î¥ë¡¼¥ó)");
2377 #else
2378                                         t = object_desc_str(t, " (Summoning Runes)");
2379 #endif
2380                                         break;
2381                                 }
2382                                 case CHEST_RUNES_OF_EVIL:
2383                                 {
2384 #ifdef JP
2385                                         t = object_desc_str(t, "(¼Ù°­¤Ê¥ë¡¼¥ó)");
2386 #else
2387                                         t = object_desc_str(t, " (Gleaming Black Runes)");
2388 #endif
2389                                         break;
2390                                 }
2391                                 case CHEST_ALARM:
2392                                 {
2393 #ifdef JP
2394                                         t = object_desc_str(t, "(·ÙÊóÁõÃÖ)");
2395 #else
2396                                         t = object_desc_str(t, " (Alarm)");
2397 #endif
2398                                         break;
2399                                 }
2400                                 default:
2401                                 {
2402 #ifdef JP
2403                                         t = object_desc_str(t, "(¥Þ¥ë¥Á¡¦¥È¥é¥Ã¥×)");
2404 #else
2405                                         t = object_desc_str(t, " (Multiple Traps)");
2406 #endif
2407                                         break;
2408                                 }
2409                         }
2410                 }
2411         }
2412
2413
2414         /* Display the item like a weapon */
2415         if (have_flag(flgs, TR_SHOW_MODS)) show_weapon = TRUE;
2416
2417         /* Display the item like a weapon */
2418         if (object_is_smith(o_ptr) && (o_ptr->xtra3 == 1 + ESSENCE_SLAY_GLOVE))
2419                 show_weapon = TRUE;
2420
2421         /* Display the item like a weapon */
2422         if (o_ptr->to_h && o_ptr->to_d) show_weapon = TRUE;
2423
2424         /* Display the item like armour */
2425         if (o_ptr->ac) show_armour = TRUE;
2426
2427
2428         /* Dump base weapon info */
2429         switch (o_ptr->tval)
2430         {
2431                 /* Missiles and Weapons */
2432                 case TV_SHOT:
2433                 case TV_BOLT:
2434                 case TV_ARROW:
2435                 case TV_HAFTED:
2436                 case TV_POLEARM:
2437                 case TV_SWORD:
2438             case TV_DIGGING:
2439                 
2440                 /* In Vault Quest, hide the dice of target weapon. */
2441                 if(object_is_quest_target(o_ptr) && !known)
2442                 {
2443                         break;
2444                 }
2445
2446                 /* Append a "damage" string */
2447                 t = object_desc_chr(t, ' ');
2448                 t = object_desc_chr(t, p1);
2449                 t = object_desc_num(t, o_ptr->dd);
2450                 t = object_desc_chr(t, 'd');
2451                 t = object_desc_num(t, o_ptr->ds);
2452                 t = object_desc_chr(t, p2);
2453
2454                 /* All done */
2455                 break;
2456
2457
2458                 /* Bows get a special "damage string" */
2459                 case TV_BOW:
2460
2461                 /* Mega-Hack -- Extract the "base power" */
2462                 power = bow_tmul(o_ptr->sval);
2463
2464                 /* Apply the "Extra Might" flag */
2465                 if (have_flag(flgs, TR_XTRA_MIGHT)) power++;
2466
2467                 /* Append a special "damage" string */
2468                 t = object_desc_chr(t, ' ');
2469                 t = object_desc_chr(t, p1);
2470                 t = object_desc_chr(t, 'x');
2471                 t = object_desc_num(t, power);
2472                 t = object_desc_chr(t, p2);
2473                 
2474                 fire_rate = calc_num_fire(o_ptr);
2475                 /* Show Fire rate */
2476                 if (fire_rate != 0 && power > 0 && known)
2477                 {       
2478                         fire_rate = bow_energy(o_ptr->sval) / fire_rate;
2479                         
2480                         t = object_desc_chr(t, ' ');
2481                         t = object_desc_chr(t, p1);                     
2482                         t = object_desc_num(t,  fire_rate/100);
2483                         t = object_desc_chr(t,  '.');
2484                         t = object_desc_num(t,  fire_rate%100);
2485                         t = object_desc_str(t, "turn");
2486                         t = object_desc_chr(t, p2);
2487                 }
2488                 
2489                 /* All done */
2490                 break;
2491         }
2492
2493
2494         /* Add the weapon bonuses */
2495         if (known)
2496         {
2497                 /* Show the tohit/todam on request */
2498                 if (show_weapon)
2499                 {
2500                         t = object_desc_chr(t, ' ');
2501                         t = object_desc_chr(t, p1);
2502                         t = object_desc_int(t, o_ptr->to_h);
2503                         t = object_desc_chr(t, ',');
2504                         t = object_desc_int(t, o_ptr->to_d);
2505                         t = object_desc_chr(t, p2);
2506                 }
2507
2508                 /* Show the tohit if needed */
2509                 else if (o_ptr->to_h)
2510                 {
2511                         t = object_desc_chr(t, ' ');
2512                         t = object_desc_chr(t, p1);
2513                         t = object_desc_int(t, o_ptr->to_h);
2514                         t = object_desc_chr(t, p2);
2515                 }
2516
2517                 /* Show the todam if needed */
2518                 else if (o_ptr->to_d)
2519                 {
2520                         t = object_desc_chr(t, ' ');
2521                         t = object_desc_chr(t, p1);
2522                         t = object_desc_int(t, o_ptr->to_d);
2523                         t = object_desc_chr(t, p2);
2524                 }
2525         }
2526
2527         bow_ptr = &inventory[INVEN_BOW];
2528
2529         /* If have a firing weapon + ammo matches bow */
2530         if (bow_ptr->k_idx && (o_ptr->tval == p_ptr->tval_ammo))
2531         {
2532                 int avgdam = o_ptr->dd * (o_ptr->ds + 1) * 10 / 2;
2533                 int tmul = bow_tmul(bow_ptr->sval);
2534                 s16b energy_fire = bow_energy(bow_ptr->sval);
2535
2536                 /* See if the bow is "known" - then set damage bonus */
2537                 if (object_is_known(bow_ptr)) avgdam += (bow_ptr->to_d * 10);
2538
2539                 /* Effect of ammo */
2540                 if (known) avgdam += (o_ptr->to_d * 10);
2541
2542                 /* Get extra "power" from "extra might" */
2543                 if (p_ptr->xtra_might) tmul++;
2544
2545                 tmul = tmul * (100 + (int)(adj_str_td[p_ptr->stat_ind[A_STR]]) - 128);
2546
2547                 /* Launcher multiplier */
2548                 avgdam *= tmul;
2549                 avgdam /= (100 * 10);
2550
2551                 /* Get extra damage from concentration */
2552                 if (p_ptr->concent) avgdam = boost_concentration_damage(avgdam);
2553                 
2554                 if (avgdam < 0) avgdam = 0;
2555
2556                 /* Display (shot damage/ shot damage with critical/ avg damage with critical) */
2557                 t = object_desc_chr(t, ' ');
2558                 t = object_desc_chr(t, p1);
2559                 
2560                 if(show_ammo_no_crit)
2561                 {
2562                         /* Damage with no-crit */
2563                         t = object_desc_num(t, avgdam);
2564                         t = object_desc_str(t, show_ammo_detail ? "/shot " : "/");
2565                 }
2566                 
2567                 /* Apply Expect damage of Critical */
2568                 avgdam = calc_expect_crit_shot(o_ptr->weight, o_ptr->to_h, bow_ptr->to_h, avgdam);
2569                 t = object_desc_num(t, avgdam);
2570                 
2571                 t = show_ammo_no_crit ? object_desc_str(t, show_ammo_detail ? "/crit " : "/")
2572                                                           : object_desc_str(t, show_ammo_detail ? "/shot " : "/");
2573         
2574                 if (p_ptr->num_fire == 0)
2575                 {
2576                         t = object_desc_chr(t, '0');
2577                 }
2578                 else
2579                 {
2580                         /* Calc effects of energy */
2581                         avgdam *= (p_ptr->num_fire * 100);
2582                         avgdam /= energy_fire;
2583                         t = object_desc_num(t, avgdam);
2584                         t = object_desc_str(t, show_ammo_detail ? "/turn" : "");
2585                         
2586                         if(show_ammo_crit_ratio)
2587                         {
2588                                 int percent = calc_crit_ratio_shot(o_ptr->weight, 
2589                                                 known ? o_ptr->to_h : 0, 
2590                                                 object_is_known(bow_ptr) ? bow_ptr->to_h : 0,  avgdam);
2591                                 
2592                                 t = object_desc_chr(t, '/');
2593                                 t = object_desc_num(t, percent / 100);
2594                                 t = object_desc_chr(t, '.');
2595                                 t = object_desc_num(t, percent % 100);
2596                                 t = object_desc_str(t, show_ammo_detail ? "% crit" : "%");
2597                         }
2598                 }
2599
2600                 t = object_desc_chr(t, p2);
2601         }
2602         else if ((p_ptr->pclass == CLASS_NINJA) && (o_ptr->tval == TV_SPIKE))
2603         {
2604                 int avgdam = p_ptr->mighty_throw ? (1 + 3) : 1;
2605                 s16b energy_fire = 100 - p_ptr->lev;
2606
2607                 avgdam += ((p_ptr->lev + 30) * (p_ptr->lev + 30) - 900) / 55;
2608
2609                 /* Display (shot damage/ avg damage) */
2610                 t = object_desc_chr(t, ' ');
2611                 t = object_desc_chr(t, p1);
2612                 t = object_desc_num(t, avgdam);
2613                 t = object_desc_chr(t, '/');
2614
2615                 /* Calc effects of energy */
2616                 avgdam = 100 * avgdam / energy_fire;
2617
2618                 t = object_desc_num(t, avgdam);
2619                 t = object_desc_chr(t, p2);
2620         }
2621
2622         /* Add the armor bonuses */
2623         if (known)
2624         {
2625                 /* Show the armor class info */
2626                 if (show_armour)
2627                 {
2628                         t = object_desc_chr(t, ' ');
2629                         t = object_desc_chr(t, b1);
2630                         t = object_desc_num(t, o_ptr->ac);
2631                         t = object_desc_chr(t, ',');
2632                         t = object_desc_int(t, o_ptr->to_a);
2633                         t = object_desc_chr(t, b2);
2634                 }
2635
2636                 /* No base armor, but does increase armor */
2637                 else if (o_ptr->to_a)
2638                 {
2639                         t = object_desc_chr(t, ' ');
2640                         t = object_desc_chr(t, b1);
2641                         t = object_desc_int(t, o_ptr->to_a);
2642                         t = object_desc_chr(t, b2);
2643                 }
2644         }
2645
2646         /* Hack -- always show base armor */
2647         else if (show_armour)
2648         {
2649                 t = object_desc_chr(t, ' ');
2650                 t = object_desc_chr(t, b1);
2651                 t = object_desc_num(t, o_ptr->ac);
2652                 t = object_desc_chr(t, b2);
2653         }
2654
2655
2656         /* No more details wanted */
2657         if (mode & OD_NAME_AND_ENCHANT) goto object_desc_done;
2658
2659
2660         if (known) /* Known item only */
2661         {
2662                 /*
2663                  * Hack -- Wands and Staffs have charges.  Make certain how many charges
2664                  * a stack of staffs really has is clear. -LM-
2665                  */
2666                 if (((o_ptr->tval == TV_STAFF) || (o_ptr->tval == TV_WAND)))
2667                 {
2668                         /* Dump " (N charges)" */
2669                         t = object_desc_chr(t, ' ');
2670                         t = object_desc_chr(t, p1);
2671
2672                         /* Clear explaination for staffs. */
2673                         if ((o_ptr->tval == TV_STAFF) && (o_ptr->number > 1))
2674                         {
2675                                 t = object_desc_num(t, o_ptr->number);
2676                                 t = object_desc_str(t, "x ");
2677                         }
2678                         t = object_desc_num(t, o_ptr->pval);
2679 #ifdef JP
2680                         t = object_desc_str(t, "²óʬ");
2681 #else
2682                         t = object_desc_str(t, " charge");
2683                         if (o_ptr->pval != 1) t = object_desc_chr(t, 's');
2684 #endif
2685
2686                         t = object_desc_chr(t, p2);
2687                 }
2688                 /* Hack -- Rods have a "charging" indicator.  Now that stacks of rods may
2689                  * be in any state of charge or discharge, this now includes a number. -LM-
2690                  */
2691                 else if (o_ptr->tval == TV_ROD)
2692                 {
2693                         /* Hack -- Dump " (# charging)" if relevant */
2694                         if (o_ptr->timeout)
2695                         {
2696                                 /* Stacks of rods display an exact count of charging rods. */
2697                                 if (o_ptr->number > 1)
2698                                 {
2699                                         /* Paranoia. */
2700                                         if (k_ptr->pval == 0) k_ptr->pval = 1;
2701
2702                                         /* Find out how many rods are charging, by dividing
2703                                          * current timeout by each rod's maximum timeout.
2704                                          * Ensure that any remainder is rounded up.  Display
2705                                          * very discharged stacks as merely fully discharged.
2706                                          */
2707                                         power = (o_ptr->timeout + (k_ptr->pval - 1)) / k_ptr->pval;
2708                                         if (power > o_ptr->number) power = o_ptr->number;
2709
2710                                         /* Display prettily. */
2711                                         t = object_desc_str(t, " (");
2712                                         t = object_desc_num(t, power);
2713 #ifdef JP
2714                                         t = object_desc_str(t, "ËÜ ½¼Å¶Ãæ)");
2715 #else
2716                                         t = object_desc_str(t, " charging)");
2717 #endif
2718                                 }
2719
2720                                 /* "one Rod of Perception (1 charging)" would look tacky. */
2721                                 else
2722                                 {
2723 #ifdef JP
2724                                         t = object_desc_str(t, "(½¼Å¶Ãæ)");
2725 #else
2726                                         t = object_desc_str(t, " (charging)");
2727 #endif
2728                                 }
2729                         }
2730                 }
2731
2732                 /* Dump "pval" flags for wearable items */
2733                 if (have_pval_flags(flgs))
2734                 {
2735                         /* Start the display */
2736                         t = object_desc_chr(t, ' ');
2737                         t = object_desc_chr(t, p1);
2738
2739                         /* Dump the "pval" itself */
2740                         t = object_desc_int(t, o_ptr->pval);
2741
2742                         /* Do not display the "pval" flags */
2743                         if (have_flag(flgs, TR_HIDE_TYPE))
2744                         {
2745                                 /* Nothing */
2746                         }
2747
2748                         /* Speed */
2749                         else if (have_flag(flgs, TR_SPEED))
2750                         {
2751                                 /* Dump " to speed" */
2752 #ifdef JP
2753                                 t = object_desc_str(t, "²Ã®");
2754 #else
2755                                 t = object_desc_str(t, " to speed");
2756 #endif
2757                         }
2758
2759                         /* Attack speed */
2760                         else if (have_flag(flgs, TR_BLOWS))
2761                         {
2762                                 /* Add " attack" */
2763 #ifdef JP
2764                                 t = object_desc_str(t, "¹¶·â");
2765 #else
2766                                 t = object_desc_str(t, " attack");
2767
2768                                 /* Add "attacks" */
2769                                 if (ABS(o_ptr->pval) != 1) t = object_desc_chr(t, 's');
2770 #endif
2771                         }
2772
2773                         /* Stealth */
2774                         else if (have_flag(flgs, TR_STEALTH))
2775                         {
2776                                 /* Dump " to stealth" */
2777 #ifdef JP
2778                                 t = object_desc_str(t, "±£Ì©");
2779 #else
2780                                 t = object_desc_str(t, " to stealth");
2781 #endif
2782                         }
2783
2784                         /* Search */
2785                         else if (have_flag(flgs, TR_SEARCH))
2786                         {
2787                                 /* Dump " to searching" */
2788 #ifdef JP
2789                                 t = object_desc_str(t, "õº÷");
2790 #else
2791                                 t = object_desc_str(t, " to searching");
2792 #endif
2793                         }
2794
2795                         /* Infravision */
2796                         else if (have_flag(flgs, TR_INFRA))
2797                         {
2798                                 /* Dump " to infravision" */
2799 #ifdef JP
2800                                 t = object_desc_str(t, "ÀÖ³°Àþ»ëÎÏ");
2801 #else
2802                                 t = object_desc_str(t, " to infravision");
2803 #endif
2804                         }
2805
2806                         /* Finish the display */
2807                         t = object_desc_chr(t, p2);
2808                 }
2809
2810                 /* Hack -- Process Lanterns/Torches */
2811                 if ((o_ptr->tval == TV_LITE) && (!(object_is_fixed_artifact(o_ptr) || (o_ptr->sval == SV_LITE_FEANOR))))
2812                 {
2813                         /* Hack -- Turns of light for normal lites */
2814 #ifdef JP
2815                         t = object_desc_chr(t, '(');
2816 #else
2817                         t = object_desc_str(t, " (with ");
2818 #endif
2819
2820                         if (o_ptr->name2 == EGO_LITE_LONG) t = object_desc_num(t, o_ptr->xtra4 * 2);
2821                         else t = object_desc_num(t, o_ptr->xtra4);
2822 #ifdef JP
2823                         t = object_desc_str(t, "¥¿¡¼¥ó¤Î¼÷Ì¿)");
2824 #else
2825                         t = object_desc_str(t, " turns of light)");
2826 #endif
2827                 }
2828
2829                 /* Indicate charging objects, but not rods. */
2830                 if (o_ptr->timeout && (o_ptr->tval != TV_ROD))
2831                 {
2832                         /* Hack -- Dump " (charging)" if relevant */
2833 #ifdef JP
2834                         t = object_desc_str(t, "(½¼Å¶Ãæ)");
2835 #else
2836                         t = object_desc_str(t, " (charging)");
2837 #endif
2838                 }
2839         }
2840
2841
2842         /* No more details wanted */
2843         if (mode & OD_OMIT_INSCRIPTION) goto object_desc_done;
2844
2845
2846         /* Prepare real inscriptions in a buffer */
2847         tmp_val2[0] = '\0';
2848
2849         /* Auto abbreviation inscribe */
2850         if ((abbrev_extra || abbrev_all) && (o_ptr->ident & IDENT_MENTAL))
2851         {
2852                 if (!o_ptr->inscription || !my_strchr(quark_str(o_ptr->inscription), '%'))
2853                 {
2854                         bool kanji, all;
2855
2856 #ifdef JP
2857                         kanji = TRUE;
2858 #else
2859                         kanji = FALSE;
2860 #endif
2861                         all = abbrev_all;
2862
2863                         get_ability_abbreviation(tmp_val2, o_ptr, kanji, all);
2864                 }
2865         }
2866
2867         /* Use the standard inscription if available */
2868         if (o_ptr->inscription)
2869         {
2870                 char buff[1024];
2871
2872                 if (tmp_val2[0]) strcat(tmp_val2, ", ");
2873
2874                 /* Get inscription and convert {%} */
2875                 get_inscription(buff, o_ptr);
2876
2877                 /* strcat with correct treating of kanji */
2878                 my_strcat(tmp_val2, buff, sizeof(tmp_val2));
2879         }
2880
2881
2882         /* No fake inscription yet */
2883         fake_insc_buf[0] = '\0';
2884
2885         /* Use the game-generated "feeling" otherwise, if available */
2886         if (o_ptr->feeling)
2887         {
2888                 strcpy(fake_insc_buf, game_inscriptions[o_ptr->feeling]);
2889         }
2890
2891         /* Note "cursed" if the item is known to be cursed */
2892         else if (object_is_cursed(o_ptr) && (known || (o_ptr->ident & IDENT_SENSE)))
2893         {
2894 #ifdef JP
2895                 strcpy(fake_insc_buf, "¼ö¤ï¤ì¤Æ¤¤¤ë");
2896 #else
2897                 strcpy(fake_insc_buf, "cursed");
2898 #endif
2899         }
2900
2901         /* Note "unidentified" if the item is unidentified */
2902         else if (((o_ptr->tval == TV_RING) || (o_ptr->tval == TV_AMULET)
2903                    || (o_ptr->tval == TV_LITE) || (o_ptr->tval == TV_FIGURINE))
2904                  && aware && !known
2905                  && !(o_ptr->ident & IDENT_SENSE))
2906         {
2907 #ifdef JP
2908                 strcpy(fake_insc_buf, "̤´ÕÄê");
2909 #else
2910                 strcpy(fake_insc_buf, "unidentified");
2911 #endif
2912         }
2913
2914         /* Mega-Hack -- note empty wands/staffs */
2915         else if (!known && (o_ptr->ident & IDENT_EMPTY))
2916         {
2917 #ifdef JP
2918                 strcpy(fake_insc_buf, "¶õ");
2919 #else
2920                 strcpy(fake_insc_buf, "empty");
2921 #endif
2922         }
2923
2924         /* Note "tried" if the object has been tested unsuccessfully */
2925         else if (!aware && object_is_tried(o_ptr))
2926         {
2927 #ifdef JP
2928                 strcpy(fake_insc_buf, "̤ȽÌÀ");
2929 #else
2930                 strcpy(fake_insc_buf, "tried");
2931 #endif
2932         }
2933
2934         /* Note the discount, if any */
2935         if (o_ptr->discount)
2936         {
2937                 /* Hidden by real inscription unless in a store */
2938                 if (!tmp_val2[0] || (o_ptr->ident & IDENT_STORE))
2939                 {
2940                         char discount_num_buf[4];
2941
2942                         /* Append to other fake inscriptions if any */
2943                         if (fake_insc_buf[0]) strcat(fake_insc_buf, ", ");
2944
2945                         (void)object_desc_num(discount_num_buf, o_ptr->discount);
2946                         strcat(fake_insc_buf, discount_num_buf);
2947 #ifdef JP
2948                         strcat(fake_insc_buf, "%°ú¤­");
2949 #else
2950                         strcat(fake_insc_buf, "% off");
2951 #endif
2952                 }
2953         }
2954
2955
2956         /* Append the inscription, if any */
2957         if (fake_insc_buf[0] || tmp_val2[0])
2958         {
2959                 /* Append the inscription */
2960                 t = object_desc_chr(t, ' ');
2961                 t = object_desc_chr(t, c1);
2962
2963                 /* Append fake inscriptions */
2964                 if (fake_insc_buf[0])
2965                 {
2966                         t = object_desc_str(t, fake_insc_buf);
2967                 }
2968
2969                 /* Append a separater */
2970                 if (fake_insc_buf[0] && tmp_val2[0])
2971                 {
2972                         t = object_desc_chr(t, ',');
2973                         t = object_desc_chr(t, ' ');
2974                 }
2975
2976                 /* Append real inscriptions */
2977                 if (tmp_val2[0])
2978                 {
2979                         t = object_desc_str(t, tmp_val2);
2980                 }
2981
2982                 t = object_desc_chr(t, c2);
2983         }
2984
2985 object_desc_done:
2986         my_strcpy(buf, tmp_val, MAX_NLEN);
2987 }
2988
2989
変愚蛮怒のメインリポジトリです
About OSDN
Find Software
Develop Software
Help