OSDN Git Service

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