OSDN Git Service

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


9e56104c1f687de16bb3f39dfdb488aabbd30074
[hengband/hengband.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 /*
498  * Create a name from random parts.
499  */
500 void get_table_name_aux(char *out_string)
501 {
502 #ifdef JP
503         char Syllable[80];
504         get_rnd_line("aname_j.txt", 1, Syllable);
505         strcpy(out_string, Syllable);
506         get_rnd_line("aname_j.txt", 2, Syllable);
507         strcat(out_string, Syllable);
508 #else
509         int testcounter = randint1(3) + 1;
510
511         strcpy(out_string, "");
512
513         if (randint1(3) == 2)
514         {
515                 while (testcounter--)
516                         strcat(out_string, syllables[randint0(MAX_SYLLABLES)]);
517         }
518         else
519         {
520                 char Syllable[80];
521                 testcounter = randint1(2) + 1;
522                 while (testcounter--)
523                 {
524                         (void)get_rnd_line("elvish.txt", 0, Syllable);
525                         strcat(out_string, Syllable);
526                 }
527         }
528
529         out_string[0] = toupper(out_string[1]);
530
531         out_string[16] = '\0';
532 #endif
533 }
534
535
536 /*
537  * Create a name from random parts without quotes.
538  */
539 void get_table_name(char *out_string)
540 {
541         char buff[80];
542         get_table_name_aux(buff);
543
544 #ifdef JP
545         sprintf(out_string, "¡Ø%s¡Ù", buff);
546 #else
547         sprintf(out_string, "'%s'", buff);
548 #endif
549 }
550
551
552 /*
553  * Prepare the "variable" part of the "k_info" array.
554  *
555  * The "color"/"metal"/"type" of an item is its "flavor".
556  * For the most part, flavors are assigned randomly each game.
557  *
558  * Initialize descriptions for the "colored" objects, including:
559  * Rings, Amulets, Staffs, Wands, Rods, Food, Potions, Scrolls.
560  *
561  * The first 4 entries for potions are fixed (Water, Apple Juice,
562  * Slime Mold Juice, Unused Potion).
563  *
564  * Scroll titles are always between 6 and 14 letters long.  This is
565  * ensured because every title is composed of whole words, where every
566  * word is from 1 to 8 letters long (one or two syllables of 1 to 4
567  * letters each), and that no scroll is finished until it attempts to
568  * grow beyond 15 letters.  The first time this can happen is when the
569  * current title has 6 letters and the new word has 8 letters, which
570  * would result in a 6 letter scroll title.
571  *
572  * Duplicate titles are avoided by requiring that no two scrolls share
573  * the same first four letters (not the most efficient method, and not
574  * the least efficient method, but it will always work).
575  *
576  * Hack -- make sure everything stays the same for each saved game
577  * This is accomplished by the use of a saved "random seed", as in
578  * "town_gen()".  Since no other functions are called while the special
579  * seed is in effect, so this function is pretty "safe".
580  *
581  * Note that the "hacked seed" may provide an RNG with alternating parity!
582  */
583 void flavor_init(void)
584 {
585         int     i, j;
586
587         byte    temp_col;
588
589         cptr    temp_adj;
590
591
592         /* Hack -- Use the "simple" RNG */
593         Rand_quick = TRUE;
594
595         /* Hack -- Induce consistant flavors */
596         Rand_value = seed_flavor;
597
598
599         /* Efficiency -- Rods/Wands share initial array */
600         for (i = 0; i < MAX_METALS; i++)
601         {
602                 rod_adj[i] = wand_adj[i];
603                 rod_col[i] = wand_col[i];
604         }
605
606
607         /* Rings have "ring colors" */
608         for (i = 0; i < MAX_ROCKS; i++)
609         {
610                 j = randint0(MAX_ROCKS);
611                 temp_adj = ring_adj[i];
612                 ring_adj[i] = ring_adj[j];
613                 ring_adj[j] = temp_adj;
614
615                 temp_col = ring_col[i];
616                 ring_col[i] = ring_col[j];
617                 ring_col[j] = temp_col;
618         }
619
620         /* Hack -- The One Ring */
621 #ifdef JP
622         ring_adj[SV_RING_POWER] = "¶â̵¹¤¤Î";
623         ring_adj[SV_RING_AHO] = "¶âÍ­¹¤¤Î";
624 #else
625         ring_adj[SV_RING_POWER] = "Plain Gold";
626         ring_adj[SV_RING_AHO] = "Plain Goldarn";
627 #endif
628
629         if (!use_graphics)
630         {
631                 ring_col[SV_RING_POWER] = TERM_YELLOW;
632                 ring_col[SV_RING_AHO] = TERM_YELLOW;
633         }
634
635         /* Amulets have "amulet colors" */
636         for (i = 0; i < MAX_AMULETS; i++)
637         {
638                 j = randint0(MAX_AMULETS);
639                 temp_adj = amulet_adj[i];
640                 amulet_adj[i] = amulet_adj[j];
641                 amulet_adj[j] = temp_adj;
642
643                 temp_col = amulet_col[i];
644                 amulet_col[i] = amulet_col[j];
645                 amulet_col[j] = temp_col;
646         }
647
648         /* Staffs */
649         for (i = 0; i < MAX_WOODS; i++)
650         {
651                 j = randint0(MAX_WOODS);
652                 temp_adj = staff_adj[i];
653                 staff_adj[i] = staff_adj[j];
654                 staff_adj[j] = temp_adj;
655
656                 temp_col = staff_col[i];
657                 staff_col[i] = staff_col[j];
658                 staff_col[j] = temp_col;
659         }
660
661         /* Wands */
662         for (i = 0; i < MAX_METALS; i++)
663         {
664                 j = randint0(MAX_METALS);
665                 temp_adj = wand_adj[i];
666                 wand_adj[i] = wand_adj[j];
667                 wand_adj[j] = temp_adj;
668
669                 temp_col = wand_col[i];
670                 wand_col[i] = wand_col[j];
671                 wand_col[j] = temp_col;
672         }
673
674         /* Rods */
675         for (i = 0; i < MAX_METALS; i++)
676         {
677                 j = randint0(MAX_METALS);
678                 temp_adj = rod_adj[i];
679                 rod_adj[i] = rod_adj[j];
680                 rod_adj[j] = temp_adj;
681
682                 temp_col = rod_col[i];
683                 rod_col[i] = rod_col[j];
684                 rod_col[j] = temp_col;
685         }
686
687         /* Foods (Mushrooms) */
688         for (i = 0; i < MAX_SHROOM; i++)
689         {
690                 j = randint0(MAX_SHROOM);
691                 temp_adj = food_adj[i];
692                 food_adj[i] = food_adj[j];
693                 food_adj[j] = temp_adj;
694
695                 temp_col = food_col[i];
696                 food_col[i] = food_col[j];
697                 food_col[j] = temp_col;
698         }
699
700         /* Potions */
701         for (i = 4; i < MAX_COLORS; i++)
702         {
703                 j = randint0(MAX_COLORS - 4) + 4;
704                 temp_adj = potion_adj[i];
705                 potion_adj[i] = potion_adj[j];
706                 potion_adj[j] = temp_adj;
707
708                 temp_col = potion_col[i];
709                 potion_col[i] = potion_col[j];
710                 potion_col[j] = temp_col;
711         }
712
713         /* Scrolls (random titles, always white) */
714         for (i = 0; i < MAX_TITLES; i++)
715         {
716                 /* Get a new title */
717                 while (TRUE)
718                 {
719                         char buf[80];
720
721                         bool okay;
722
723                         /* Start a new title */
724                         buf[0] = '\0';
725
726                         /* Collect words until done */
727                         while (1)
728                         {
729                                 int q, s;
730
731                                 char tmp[80];
732
733                                 /* Start a new word */
734                                 tmp[0] = '\0';
735
736                                 /* Choose one or two syllables */
737                                 s = ((randint0(100) < 30) ? 1 : 2);
738
739                                 /* Add a one or two syllable word */
740                                 for (q = 0; q < s; q++)
741                                 {
742                                         /* Add the syllable */
743                                         strcat(tmp, syllables[randint0(MAX_SYLLABLES)]);
744                                 }
745
746                                 /* Stop before getting too long */
747                                 if (strlen(buf) + 1 + strlen(tmp) > 15) break;
748
749                                 /* Add a space */
750                                 strcat(buf, " ");
751
752                                 /* Add the word */
753                                 strcat(buf, tmp);
754                         }
755
756                         /* Save the title */
757                         strcpy(scroll_adj[i], buf+1);
758
759                         /* Assume okay */
760                         okay = TRUE;
761
762                         /* Check for "duplicate" scroll titles */
763                         for (j = 0; j < i; j++)
764                         {
765                                 cptr hack1 = scroll_adj[j];
766                                 cptr hack2 = scroll_adj[i];
767
768                                 /* Compare first four characters */
769                                 if (*hack1++ != *hack2++) continue;
770                                 if (*hack1++ != *hack2++) continue;
771                                 if (*hack1++ != *hack2++) continue;
772                                 if (*hack1++ != *hack2++) continue;
773
774                                 /* Not okay */
775                                 okay = FALSE;
776
777                                 /* Stop looking */
778                                 break;
779                         }
780
781                         /* Break when done */
782                         if (okay) break;
783                 }
784
785                 /* All scrolls are white */
786                 scroll_col[i] = TERM_WHITE;
787         }
788
789
790         /* Hack -- Use the "complex" RNG */
791         Rand_quick = FALSE;
792
793         /* Analyze every object */
794         for (i = 1; i < max_k_idx; i++)
795         {
796                 object_kind *k_ptr = &k_info[i];
797
798                 /* Skip "empty" objects */
799                 if (!k_ptr->name) continue;
800
801                 /* Extract "flavor" (if any) */
802                 k_ptr->flavor = object_flavor(i);
803
804                 /* No flavor yields aware */
805                 if (!k_ptr->flavor) k_ptr->aware = TRUE;
806
807                 /* Check for "easily known" */
808                 k_ptr->easy_know = object_easy_know(i);
809         }
810 }
811
812
813 /*
814  * Print a char "c" into a string "t", as if by sprintf(t, "%c", c),
815  * and return a pointer to the terminator (t + 1).
816  */
817 static char *object_desc_chr(char *t, char c)
818 {
819         /* Copy the char */
820         *t++ = c;
821
822         /* Terminate */
823         *t = '\0';
824
825         /* Result */
826         return (t);
827 }
828
829
830 /*
831  * Print a string "s" into a string "t", as if by strcpy(t, s),
832  * and return a pointer to the terminator.
833  */
834 static char *object_desc_str(char *t, cptr s)
835 {
836         /* Copy the string */
837         while (*s) *t++ = *s++;
838
839         /* Terminate */
840         *t = '\0';
841
842         /* Result */
843         return (t);
844 }
845
846
847
848 /*
849  * Print an unsigned number "n" into a string "t", as if by
850  * sprintf(t, "%u", n), and return a pointer to the terminator.
851  */
852 static char *object_desc_num(char *t, uint n)
853 {
854         uint p;
855
856         /* Find "size" of "n" */
857         for (p = 1; n >= p * 10; p = p * 10) /* loop */;
858
859         /* Dump each digit */
860         while (p >= 1)
861         {
862                 /* Dump the digit */
863                 *t++ = '0' + n / p;
864
865                 /* Remove the digit */
866                 n = n % p;
867
868                 /* Process next digit */
869                 p = p / 10;
870         }
871
872         /* Terminate */
873         *t = '\0';
874
875         /* Result */
876         return (t);
877 }
878
879
880
881
882 #ifdef JP
883 /*
884  * ÆüËܸì¤Î¸Ä¿ôɽ¼¨¥ë¡¼¥Á¥ó
885  *¡Êcmd1.c ¤ÇήÍѤ¹¤ë¤¿¤á¤Ë object_desc_japanese ¤«¤é°ÜÆ°¤·¤¿¡£¡Ë
886  */
887
888 char *object_desc_kosuu(char *t, object_type *o_ptr)
889 {
890     t = object_desc_num(t, o_ptr->number);
891
892     switch (o_ptr->tval)
893     {
894       case TV_BOLT:
895       case TV_ARROW:
896       case TV_POLEARM:
897       case TV_STAFF:
898       case TV_WAND:
899       case TV_ROD:
900       case TV_DIGGING:
901       {
902           t = object_desc_str(t, "ËÜ");
903           break;
904       }
905       case TV_SCROLL:
906       {
907           t = object_desc_str(t, "´¬");
908           break;
909       }
910       case TV_POTION:
911       {
912           t = object_desc_str(t, "Éþ");
913           break;
914       }
915       case  TV_LIFE_BOOK:
916       case  TV_SORCERY_BOOK:
917       case  TV_NATURE_BOOK:
918       case  TV_CHAOS_BOOK:
919       case  TV_DEATH_BOOK:
920       case  TV_TRUMP_BOOK:
921       case  TV_ARCANE_BOOK:
922       case  TV_ENCHANT_BOOK:
923       case  TV_DAEMON_BOOK:
924       case  TV_CRUSADE_BOOK:
925       case  TV_MUSIC_BOOK:
926       case  TV_HISSATSU_BOOK:
927       {
928           t = object_desc_str(t, "ºý");
929           break;
930       }
931       case TV_SOFT_ARMOR:
932       case TV_HARD_ARMOR:
933       case TV_DRAG_ARMOR:
934       case TV_CLOAK:
935       {
936           t = object_desc_str(t, "Ãå");
937           break;
938       }
939       case TV_SWORD:
940       case TV_HAFTED:
941       case TV_BOW:
942       {
943           t = object_desc_str(t, "¿¶");
944           break;
945       }
946       case TV_BOOTS:
947       {
948           t = object_desc_str(t, "­");
949           break;
950       }
951       case TV_CARD:
952       {
953           t = object_desc_str(t, "Ëç");
954           break;
955       }
956             /* ¿©¤Ù¤â¤Î by ita */
957       case TV_FOOD:
958       {
959           if(o_ptr->sval == SV_FOOD_JERKY)
960           {
961               t = object_desc_str(t, "ÀÚ¤ì");
962               break;
963           }
964       }
965       default:
966       {
967           if (o_ptr->number < 10)
968           {
969               t = object_desc_str(t, "¤Ä");
970           }
971           else
972           {
973               t = object_desc_str(t, "¸Ä");
974           }
975           break;
976       }
977   }
978   return (t);                  
979 }
980 #endif
981
982 /*
983  * Print an signed number "v" into a string "t", as if by
984  * sprintf(t, "%+d", n), and return a pointer to the terminator.
985  * Note that we always print a sign, either "+" or "-".
986  */
987 static char *object_desc_int(char *t, sint v)
988 {
989         uint p, n;
990
991         /* Negative */
992         if (v < 0)
993         {
994                 /* Take the absolute value */
995                 n = 0 - v;
996
997                 /* Use a "minus" sign */
998                 *t++ = '-';
999         }
1000
1001         /* Positive (or zero) */
1002         else
1003         {
1004                 /* Use the actual number */
1005                 n = v;
1006
1007                 /* Use a "plus" sign */
1008                 *t++ = '+';
1009         }
1010
1011         /* Find "size" of "n" */
1012         for (p = 1; n >= p * 10; p = p * 10) /* loop */;
1013
1014         /* Dump each digit */
1015         while (p >= 1)
1016         {
1017                 /* Dump the digit */
1018                 *t++ = '0' + n / p;
1019
1020                 /* Remove the digit */
1021                 n = n % p;
1022
1023                 /* Process next digit */
1024                 p = p / 10;
1025         }
1026
1027         /* Terminate */
1028         *t = '\0';
1029
1030         /* Result */
1031         return (t);
1032 }
1033
1034
1035 /*
1036  * Structs and tables for Auto Inscription for flags
1037  */
1038
1039 typedef struct flag_insc_table
1040 {
1041 #ifdef JP
1042         cptr japanese;
1043 #endif
1044         cptr english;
1045         int flag;
1046         int except_flag;
1047 } flag_insc_table;
1048
1049 #ifdef JP
1050 static flag_insc_table flag_insc_plus[] =
1051 {
1052         { "¹¶", "At", TR_BLOWS, -1 },
1053         { "®", "Sp", TR_SPEED, -1 },
1054         { "ÏÓ", "St", TR_STR, -1 },
1055         { "ÃÎ", "In", TR_INT, -1 },
1056         { "¸­", "Wi", TR_WIS, -1 },
1057         { "´ï", "Dx", TR_DEX, -1 },
1058         { "ÂÑ", "Cn", TR_CON, -1 },
1059         { "̥", "Ch", TR_CHR, -1 },
1060         { "ƻ", "Md", TR_MAGIC_MASTERY, -1 },
1061         { "±£", "Sl", TR_STEALTH, -1 },
1062         { "õ", "Sr", TR_SEARCH, -1 },
1063         { "ÀÖ", "If", TR_INFRA, -1 },
1064         { "·¡", "Dg", TR_TUNNEL, -1 },
1065         { NULL, NULL, 0, -1 }
1066 };
1067
1068 static flag_insc_table flag_insc_immune[] =
1069 {
1070         { "»À", "Ac", TR_IM_ACID, -1 },
1071         { "ÅÅ", "El", TR_IM_ELEC, -1 },
1072         { "²Ð", "Fi", TR_IM_FIRE, -1 },
1073         { "Îä", "Co", TR_IM_COLD, -1 },
1074         { NULL, NULL, 0, -1 }
1075 };
1076
1077 static flag_insc_table flag_insc_resistance[] =
1078 {
1079         { "»À", "Ac", TR_RES_ACID, TR_IM_ACID },
1080         { "ÅÅ", "El", TR_RES_ELEC, TR_IM_ELEC },
1081         { "²Ð", "Fi", TR_RES_FIRE, TR_IM_FIRE },
1082         { "Îä", "Co", TR_RES_COLD, TR_IM_COLD },
1083         { "ÆÇ", "Po", TR_RES_POIS, -1 },
1084         { "Á®", "Li", TR_RES_LITE, -1 },
1085         { "°Å", "Dk", TR_RES_DARK, -1 },
1086         { "ÇË", "Sh", TR_RES_SHARDS, -1 },
1087         { "ÌÕ", "Bl", TR_RES_BLIND, -1 },
1088         { "Íð", "Cf", TR_RES_CONF, -1 },
1089         { "¹ì", "So", TR_RES_SOUND, -1 },
1090         { "¹ö", "Nt", TR_RES_NETHER, -1 },
1091         { "°ø", "Nx", TR_RES_NEXUS, -1 },
1092         { "ÆÙ", "Ca", TR_RES_CHAOS, -1 },
1093         { "Îô", "Di", TR_RES_DISEN, -1 },
1094         { "¶²", "Fe", TR_RES_FEAR, -1 },
1095         { NULL, NULL, 0, -1 }
1096 };
1097
1098 static flag_insc_table flag_insc_misc[] =
1099 {
1100         { "ËâÎÏ", "Ma", TR_DEC_MANA, -1 },
1101         { "Åê", "Th", TR_THROW, -1 },
1102         { "ȿ", "Rf", TR_REFLECT, -1 },
1103         { "Ëã", "Fa", TR_FREE_ACT, -1 },
1104         { "»ë", "Si", TR_SEE_INVIS, -1 },
1105         { "·Ð", "Hl", TR_HOLD_LIFE, -1 },
1106         { "ÃÙ", "Sd", TR_SLOW_DIGEST, -1 },
1107         { "³è", "Rg", TR_REGEN, -1 },
1108         { "Éâ", "Lv", TR_LEVITATION, -1 },
1109         { "ÌÀ", "Lu", TR_LITE, -1 },
1110         { "·Ù", "Wr", TR_WARNING, -1 },
1111         { "ÇÜ", "Xm", TR_XTRA_MIGHT, -1 },
1112         { "¼Í", "Xs", TR_XTRA_SHOTS, -1 },
1113         { "½Ö", "Te", TR_TELEPORT, -1 },
1114         { "ÅÜ", "Ag", TR_AGGRAVATE, -1 },
1115         { "½Ë", "Bs", TR_BLESSED, -1 },
1116         { "´÷", "Ty", TR_TY_CURSE, -1 },
1117         { NULL, NULL, 0, -1 }
1118 };
1119
1120 static flag_insc_table flag_insc_aura[] =
1121 {
1122         { "±ê", "F", TR_SH_FIRE, -1 },
1123         { "ÅÅ", "E", TR_SH_ELEC, -1 },
1124         { "Îä", "C", TR_SH_COLD, -1 },
1125         { "Ëâ", "M", TR_NO_MAGIC, -1 },
1126         { "½Ö", "T", TR_NO_TELE, -1 },
1127         { NULL, NULL, 0, -1 }
1128 };
1129
1130 static flag_insc_table flag_insc_brand[] =
1131 {
1132         { "»À", "A", TR_BRAND_ACID, -1 },
1133         { "ÅÅ", "E", TR_BRAND_ELEC, -1 },
1134         { "¾Æ", "F", TR_BRAND_FIRE, -1 },
1135         { "Åà", "Co", TR_BRAND_COLD, -1 },
1136         { "ÆÇ", "P", TR_BRAND_POIS, -1 },
1137         { "ÆÙ", "Ca", TR_CHAOTIC, -1 },
1138         { "µÛ", "V", TR_VAMPIRIC, -1 },
1139         { "¿Ì", "Q", TR_IMPACT, -1 },
1140         { "ÀÚ", "S", TR_VORPAL, -1 },
1141         { "Íý", "M", TR_FORCE_WEAPON, -1 },
1142         { NULL, NULL, 0, -1 }
1143 };
1144
1145 static flag_insc_table flag_insc_kill[] =
1146 {
1147         { "¼Ù", "*", TR_KILL_EVIL, -1 },
1148         { "¿Í", "p", TR_KILL_HUMAN, -1 },
1149         { "ζ", "D", TR_KILL_DRAGON, -1 },
1150         { "¥ª", "o", TR_KILL_ORC, -1 },
1151         { "¥È", "T", TR_KILL_TROLL, -1 },
1152         { "µð", "P", TR_KILL_GIANT, -1 },
1153         { "¥Ç", "U", TR_KILL_DEMON, -1 },
1154         { "»à", "L", TR_KILL_UNDEAD, -1 },
1155         { "ư", "Z", TR_KILL_ANIMAL, -1 },
1156         { NULL, NULL, 0, -1 }
1157 };
1158
1159 static flag_insc_table flag_insc_slay[] =
1160 {
1161         { "¼Ù", "*", TR_SLAY_EVIL, TR_KILL_EVIL },
1162         { "¿Í", "p", TR_SLAY_HUMAN, TR_KILL_HUMAN },
1163         { "ε", "D", TR_SLAY_DRAGON, TR_KILL_DRAGON },
1164         { "¥ª", "o", TR_SLAY_ORC, TR_KILL_ORC },
1165         { "¥È", "T", TR_SLAY_TROLL, TR_KILL_TROLL },
1166         { "µð", "P", TR_SLAY_GIANT, TR_KILL_GIANT },
1167         { "¥Ç", "U", TR_SLAY_DEMON, TR_KILL_DEMON },
1168         { "»à", "L", TR_SLAY_UNDEAD, TR_KILL_UNDEAD },
1169         { "ư", "Z", TR_SLAY_ANIMAL, TR_KILL_ANIMAL },
1170         { NULL, NULL, 0, -1 }
1171 };
1172
1173 static flag_insc_table flag_insc_esp1[] =
1174 {
1175         { "´¶", "Tele", TR_TELEPATHY, -1 },
1176         { "¼Ù", "Evil", TR_ESP_EVIL, -1 },
1177         { "Á±", "Good", TR_ESP_GOOD, -1 },
1178         { "̵", "Nolv", TR_ESP_NONLIVING, -1 },
1179         { "¸Ä", "Uniq", TR_ESP_UNIQUE, -1 },
1180         { NULL, NULL, 0, -1 }
1181 };
1182
1183 static flag_insc_table flag_insc_esp2[] =
1184 {
1185         { "¿Í", "p", TR_ESP_HUMAN, -1 },
1186         { "ε", "D", TR_ESP_DRAGON, -1 },
1187         { "¥ª", "o", TR_ESP_ORC, -1 },
1188         { "¥È", "T", TR_ESP_TROLL, -1 },
1189         { "µð", "P", TR_ESP_GIANT, -1 },
1190         { "¥Ç", "U", TR_ESP_DEMON, -1 },
1191         { "»à", "L", TR_ESP_UNDEAD, -1 },
1192         { "ư", "Z", TR_ESP_ANIMAL, -1 },
1193         { NULL, NULL, 0, -1 }
1194 };
1195
1196 static flag_insc_table flag_insc_sust[] =
1197 {
1198         { "ÏÓ", "St", TR_SUST_STR, -1 },
1199         { "ÃÎ", "In", TR_SUST_INT, -1 },
1200         { "¸­", "Wi", TR_SUST_WIS, -1 },
1201         { "´ï", "Dx", TR_SUST_DEX, -1 },
1202         { "ÂÑ", "Cn", TR_SUST_CON, -1 },
1203         { "̥", "Ch", TR_SUST_CHR, -1 },
1204         { NULL, NULL, 0, -1 }
1205 };
1206
1207 #else
1208 static flag_insc_table flag_insc_plus[] =
1209 {
1210         { "At", TR_BLOWS, -1 },
1211         { "Sp", TR_SPEED, -1 },
1212         { "St", TR_STR, -1 },
1213         { "In", TR_INT, -1 },
1214         { "Wi", TR_WIS, -1 },
1215         { "Dx", TR_DEX, -1 },
1216         { "Cn", TR_CON, -1 },
1217         { "Ch", TR_CHR, -1 },
1218         { "Md", TR_MAGIC_MASTERY, -1 },
1219         { "Sl", TR_STEALTH, -1 },
1220         { "Sr", TR_SEARCH, -1 },
1221         { "If", TR_INFRA, -1 },
1222         { "Dg", TR_TUNNEL, -1 },
1223         { NULL, 0, -1 }
1224 };
1225
1226 static flag_insc_table flag_insc_immune[] =
1227 {
1228         { "Ac", TR_IM_ACID, -1 },
1229         { "El", TR_IM_ELEC, -1 },
1230         { "Fi", TR_IM_FIRE, -1 },
1231         { "Co", TR_IM_COLD, -1 },
1232         { NULL, 0, -1 }
1233 };
1234
1235 static flag_insc_table flag_insc_resistance[] =
1236 {
1237         { "Ac", TR_RES_ACID, TR_IM_ACID },
1238         { "El", TR_RES_ELEC, TR_IM_ELEC },
1239         { "Fi", TR_RES_FIRE, TR_IM_FIRE },
1240         { "Co", TR_RES_COLD, TR_IM_COLD },
1241         { "Po", TR_RES_POIS, -1 },
1242         { "Li", TR_RES_LITE, -1 },
1243         { "Dk", TR_RES_DARK, -1 },
1244         { "Sh", TR_RES_SHARDS, -1 },
1245         { "Bl", TR_RES_BLIND, -1 },
1246         { "Cf", TR_RES_CONF, -1 },
1247         { "So", TR_RES_SOUND, -1 },
1248         { "Nt", TR_RES_NETHER, -1 },
1249         { "Nx", TR_RES_NEXUS, -1 },
1250         { "Ca", TR_RES_CHAOS, -1 },
1251         { "Di", TR_RES_DISEN, -1 },
1252         { "Fe", TR_RES_FEAR, -1 },
1253         { NULL, 0, -1 }
1254 };
1255
1256 static flag_insc_table flag_insc_misc[] =
1257 {
1258         { "Ma", TR_DEC_MANA, -1 },
1259         { "Th", TR_THROW, -1 },
1260         { "Rf", TR_REFLECT, -1 },
1261         { "Fa", TR_FREE_ACT, -1 },
1262         { "Si", TR_SEE_INVIS, -1 },
1263         { "Hl", TR_HOLD_LIFE, -1 },
1264         { "Sd", TR_SLOW_DIGEST, -1 },
1265         { "Rg", TR_REGEN, -1 },
1266         { "Lv", TR_LEVITATION, -1 },
1267         { "Lu", TR_LITE, -1 },
1268         { "Wr", TR_WARNING, -1 },
1269         { "Xm", TR_XTRA_MIGHT, -1 },
1270         { "Xs", TR_XTRA_SHOTS, -1 },
1271         { "Te", TR_TELEPORT, -1 },
1272         { "Ag", TR_AGGRAVATE, -1 },
1273         { "Bs", TR_BLESSED, -1 },
1274         { "Ty", TR_TY_CURSE, -1 },
1275         { NULL, 0, -1 }
1276 };
1277
1278 static flag_insc_table flag_insc_aura[] =
1279 {
1280         { "F", TR_SH_FIRE, -1 },
1281         { "E", TR_SH_ELEC, -1 },
1282         { "C", TR_SH_COLD, -1 },
1283         { "M", TR_NO_MAGIC, -1 },
1284         { "T", TR_NO_TELE, -1 },
1285         { NULL, 0, -1 }
1286 };
1287
1288 static flag_insc_table flag_insc_brand[] =
1289 {
1290         { "A", TR_BRAND_ACID, -1 },
1291         { "E", TR_BRAND_ELEC, -1 },
1292         { "F", TR_BRAND_FIRE, -1 },
1293         { "Co", TR_BRAND_COLD, -1 },
1294         { "P", TR_BRAND_POIS, -1 },
1295         { "Ca", TR_CHAOTIC, -1 },
1296         { "V", TR_VAMPIRIC, -1 },
1297         { "Q", TR_IMPACT, -1 },
1298         { "S", TR_VORPAL, -1 },
1299         { "M", TR_FORCE_WEAPON, -1 },
1300         { NULL, 0, -1 }
1301 };
1302
1303 static flag_insc_table flag_insc_kill[] =
1304 {
1305         { "*", TR_KILL_EVIL, -1 },
1306         { "p", TR_KILL_HUMAN, -1 },
1307         { "D", TR_KILL_DRAGON, -1 },
1308         { "o", TR_KILL_ORC, -1 },
1309         { "T", TR_KILL_TROLL, -1 },
1310         { "P", TR_KILL_GIANT, -1 },
1311         { "U", TR_KILL_DEMON, -1 },
1312         { "L", TR_KILL_UNDEAD, -1 },
1313         { "Z", TR_KILL_ANIMAL, -1 },
1314         { NULL, 0, -1 }
1315 };
1316
1317 static flag_insc_table flag_insc_slay[] =
1318 {
1319         { "*", TR_SLAY_EVIL, TR_KILL_EVIL },
1320         { "p", TR_SLAY_HUMAN, TR_KILL_HUMAN },
1321         { "D", TR_SLAY_DRAGON, TR_KILL_DRAGON },
1322         { "o", TR_SLAY_ORC, TR_KILL_ORC },
1323         { "T", TR_SLAY_TROLL, TR_KILL_TROLL },
1324         { "P", TR_SLAY_GIANT, TR_KILL_GIANT },
1325         { "U", TR_SLAY_DEMON, TR_KILL_DEMON },
1326         { "L", TR_SLAY_UNDEAD, TR_KILL_UNDEAD },
1327         { "Z", TR_SLAY_ANIMAL, TR_KILL_ANIMAL },
1328         { NULL, 0, -1 }
1329 };
1330
1331 static flag_insc_table flag_insc_esp1[] =
1332 {
1333         { "Tele", TR_TELEPATHY, -1 },
1334         { "Evil", TR_ESP_EVIL, -1 },
1335         { "Good", TR_ESP_GOOD, -1 },
1336         { "Nolv", TR_ESP_NONLIVING, -1 },
1337         { "Uniq", TR_ESP_UNIQUE, -1 },
1338         { NULL, 0, -1 }
1339 };
1340
1341 static flag_insc_table flag_insc_esp2[] =
1342 {
1343         { "p", TR_ESP_HUMAN, -1 },
1344         { "D", TR_ESP_DRAGON, -1 },
1345         { "o", TR_ESP_ORC, -1 },
1346         { "T", TR_ESP_TROLL, -1 },
1347         { "P", TR_ESP_GIANT, -1 },
1348         { "U", TR_ESP_DEMON, -1 },
1349         { "L", TR_ESP_UNDEAD, -1 },
1350         { "Z", TR_ESP_ANIMAL, -1 },
1351         { NULL, 0, -1 }
1352 };
1353
1354 static flag_insc_table flag_insc_sust[] =
1355 {
1356         { "St", TR_SUST_STR, -1 },
1357         { "In", TR_SUST_INT, -1 },
1358         { "Wi", TR_SUST_WIS, -1 },
1359         { "Dx", TR_SUST_DEX, -1 },
1360         { "Cn", TR_SUST_CON, -1 },
1361         { "Ch", TR_SUST_CHR, -1 },
1362         { NULL, 0, -1 }
1363 };
1364 #endif
1365
1366 /* Simple macro for get_inscription() */
1367 #define ADD_INSC(STR) (void)(ptr = object_desc_str(ptr, (STR)))
1368
1369 /*
1370  *  Helper function for get_inscription()
1371  */
1372 static char *inscribe_flags_aux(flag_insc_table *fi_ptr, u32b flgs[TR_FLAG_SIZE], bool kanji, char *ptr)
1373 {
1374 #ifndef JP
1375         (void)kanji;
1376 #endif
1377
1378         while (fi_ptr->english)
1379         {
1380                 if (have_flag(flgs, fi_ptr->flag) &&
1381                     (fi_ptr->except_flag == -1 || !have_flag(flgs, fi_ptr->except_flag)))
1382 #ifdef JP
1383                         ADD_INSC(kanji ? fi_ptr->japanese : fi_ptr->english);
1384 #else
1385                         ADD_INSC(fi_ptr->english);
1386 #endif
1387                 fi_ptr++;
1388         }
1389
1390         return ptr;
1391 }
1392
1393
1394 /*
1395  *  Special variation of have_flag for auto-inscription
1396  */
1397 static bool have_flag_of(flag_insc_table *fi_ptr, u32b flgs[TR_FLAG_SIZE])
1398 {
1399         while (fi_ptr->english)
1400         {
1401                 if (have_flag(flgs, fi_ptr->flag) &&
1402                    (fi_ptr->except_flag == -1 || !have_flag(flgs, fi_ptr->except_flag)))
1403                         return (TRUE);
1404                 fi_ptr++;
1405         }
1406
1407         return (FALSE);
1408 }
1409
1410 static char *get_ability_abbreviation(char *ptr, object_type *o_ptr, bool kanji, bool all)
1411 {
1412         char *prev_ptr = ptr;
1413         u32b flgs[TR_FLAG_SIZE];
1414
1415         /* Extract the flags */
1416         object_flags(o_ptr, flgs);
1417
1418
1419         /* Remove obvious flags */
1420         if (!all)
1421         {
1422                 object_kind *k_ptr = &k_info[o_ptr->k_idx];
1423                 int j;
1424                                 
1425                 /* Base object */
1426                 for (j = 0; j < TR_FLAG_SIZE; j++)
1427                         flgs[j] &= ~k_ptr->flags[j];
1428
1429                 if (object_is_fixed_artifact(o_ptr))
1430                 {
1431                         artifact_type *a_ptr = &a_info[o_ptr->name1];
1432                                         
1433                         for (j = 0; j < TR_FLAG_SIZE; j++)
1434                                 flgs[j] &= ~a_ptr->flags[j];
1435                 }
1436
1437                 if (object_is_ego(o_ptr))
1438                 {
1439                         ego_item_type *e_ptr = &e_info[o_ptr->name2];
1440                                         
1441                         for (j = 0; j < TR_FLAG_SIZE; j++)
1442                                 flgs[j] &= ~e_ptr->flags[j];
1443                 }
1444         }
1445
1446
1447         /* Plusses */
1448         if (have_flag_of(flag_insc_plus, flgs))
1449         {
1450                 if (kanji)
1451                         ADD_INSC("+");
1452         }
1453         ptr = inscribe_flags_aux(flag_insc_plus, flgs, kanji, ptr);
1454
1455         /* Immunity */
1456         if (have_flag_of(flag_insc_immune, flgs))
1457         {
1458                 if (!kanji && ptr != prev_ptr)
1459                 {
1460                         ADD_INSC(";");
1461                         prev_ptr = ptr;
1462                 }
1463                 ADD_INSC("*");
1464         }
1465         ptr = inscribe_flags_aux(flag_insc_immune, flgs, kanji, ptr);
1466
1467         /* Resistance */
1468         if (have_flag_of(flag_insc_resistance, flgs))
1469         {
1470                 if (kanji)
1471                         ADD_INSC("r");
1472                 else if (ptr != prev_ptr)
1473                 {
1474                         ADD_INSC(";");
1475                         prev_ptr = ptr;
1476                 }
1477         }
1478         ptr = inscribe_flags_aux(flag_insc_resistance, flgs, kanji, ptr);
1479
1480         /* Misc Ability */
1481         if (have_flag_of(flag_insc_misc, flgs))
1482         {
1483                 if (ptr != prev_ptr)
1484                 {
1485                         ADD_INSC(";");
1486                         prev_ptr = ptr;
1487                 }
1488         }
1489         ptr = inscribe_flags_aux(flag_insc_misc, flgs, kanji, ptr);
1490
1491         /* Aura */
1492         if (have_flag_of(flag_insc_aura, flgs))
1493         {
1494                 ADD_INSC("[");
1495         }
1496         ptr = inscribe_flags_aux(flag_insc_aura, flgs, kanji, ptr);
1497
1498         /* Brand Weapon */
1499         if (have_flag_of(flag_insc_brand, flgs))
1500                 ADD_INSC("|");
1501         ptr = inscribe_flags_aux(flag_insc_brand, flgs, kanji, ptr);
1502
1503         /* Kill Weapon */
1504         if (have_flag_of(flag_insc_kill, flgs))
1505                 ADD_INSC("/X");
1506         ptr = inscribe_flags_aux(flag_insc_kill, flgs, kanji, ptr);
1507
1508         /* Slay Weapon */
1509         if (have_flag_of(flag_insc_slay, flgs))
1510                 ADD_INSC("/");
1511         ptr = inscribe_flags_aux(flag_insc_slay, flgs, kanji, ptr);
1512
1513         /* Esp */
1514         if (kanji)
1515         {
1516                 if (have_flag_of(flag_insc_esp1, flgs) ||
1517                     have_flag_of(flag_insc_esp2, flgs))
1518                         ADD_INSC("~");
1519                 ptr = inscribe_flags_aux(flag_insc_esp1, flgs, kanji, ptr);
1520                 ptr = inscribe_flags_aux(flag_insc_esp2, flgs, kanji, ptr);
1521         }
1522         else
1523         {
1524                 if (have_flag_of(flag_insc_esp1, flgs))
1525                         ADD_INSC("~");
1526                 ptr = inscribe_flags_aux(flag_insc_esp1, flgs, kanji, ptr);
1527                 if (have_flag_of(flag_insc_esp2, flgs))
1528                         ADD_INSC("~");
1529                 ptr = inscribe_flags_aux(flag_insc_esp2, flgs, kanji, ptr);
1530         }
1531
1532         /* sustain */
1533         if (have_flag_of(flag_insc_sust, flgs))
1534         {
1535                 ADD_INSC("(");
1536         }
1537         ptr = inscribe_flags_aux(flag_insc_sust, flgs, kanji, ptr);
1538
1539         *ptr = '\0';
1540
1541         return ptr;
1542 }
1543
1544
1545 /*
1546  *  Get object inscription with auto inscription of object flags.
1547  */
1548 static void get_inscription(char *buff, object_type *o_ptr)
1549 {
1550         cptr insc = quark_str(o_ptr->inscription);
1551         char *ptr = buff;
1552
1553         /* Not fully identified */
1554         if (!(o_ptr->ident & IDENT_MENTAL))
1555         {
1556                 /* Copy until end of line or '#' */
1557                 while (*insc)
1558                 {
1559                         if (*insc == '#') break;
1560 #ifdef JP
1561                         if (iskanji(*insc)) *buff++ = *insc++;
1562 #endif
1563                         *buff++ = *insc++;
1564                 }
1565
1566                 *buff = '\0';
1567                 return;
1568         }
1569
1570         *buff = '\0';
1571         for (; *insc; insc++)
1572         {
1573                 /* Ignore fake artifact inscription */
1574                 if (*insc == '#') break;
1575
1576                 /* {%} will be automatically converted */
1577                 else if ('%' == *insc)
1578                 {
1579                         bool kanji = FALSE;
1580                         bool all;
1581                         cptr start = ptr;
1582
1583                         /* check for too long inscription */
1584                         if (ptr >= buff + MAX_NLEN) continue;
1585
1586 #ifdef JP
1587                         if ('%' == insc[1])
1588                         {
1589                                 insc++;
1590                                 kanji = FALSE;
1591                         }
1592                         else
1593                         {
1594                                 kanji = TRUE;
1595                         }
1596 #endif
1597                         if ('a' == insc[1] && 'l' == insc[2] && 'l' == insc[3])
1598                         {
1599                                 all = TRUE;
1600                                 insc += 3;
1601                         }
1602                         else
1603                         {
1604                                 all = FALSE;
1605                         }
1606
1607                         ptr = get_ability_abbreviation(ptr, o_ptr, kanji, all);
1608
1609                         if (ptr == start)
1610                                 ADD_INSC(" ");
1611                 }
1612                 else
1613                 {
1614                         *ptr++ = *insc;
1615                 }
1616         }
1617         *ptr = '\0';
1618 }
1619
1620
1621 /*
1622  * Creates a description of the item "o_ptr", and stores it in "out_val".
1623  *
1624  * One can choose the "verbosity" of the description, including whether
1625  * or not the "number" of items should be described, and how much detail
1626  * should be used when describing the item.
1627  *
1628  * The given "buf" must be MAX_NLEN chars long to hold the longest possible
1629  * description, which can get pretty long, including incriptions, such as:
1630  * "no more Maces of Disruption (Defender) (+10,+10) [+5] (+3 to stealth)".
1631  * Note that the inscription will be clipped to keep the total description
1632  * under MAX_NLEN-1 chars (plus a terminator).
1633  *
1634  * Note the use of "object_desc_num()" and "object_desc_int()" as hyper-efficient,
1635  * portable, versions of some common "sprintf()" commands.
1636  *
1637  * Note that all ego-items (when known) append an "Ego-Item Name", unless
1638  * the item is also an artifact, which should NEVER happen.
1639  *
1640  * Note that all artifacts (when known) append an "Artifact Name", so we
1641  * have special processing for "Specials" (artifact Lites, Rings, Amulets).
1642  * The "Specials" never use "modifiers" if they are "known", since they
1643  * have special "descriptions", such as "The Necklace of the Dwarves".
1644  *
1645  * Special Lite's use the "k_info" base-name (Phial, Star, or Arkenstone),
1646  * plus the artifact name, just like any other artifact, if known.
1647  *
1648  * Special Ring's and Amulet's, if not "aware", use the same code as normal
1649  * rings and amulets, and if "aware", use the "k_info" base-name (Ring or
1650  * Amulet or Necklace).  They will NEVER "append" the "k_info" name.  But,
1651  * they will append the artifact name, just like any artifact, if known.
1652  *
1653  * Hack -- Display "The One Ring" as "a Plain Gold Ring" until aware.
1654  *
1655  * Mode:
1656  *   OD_NAME_ONLY        : The Cloak of Death
1657  *   OD_NAME_AND_ENCHANT : The Cloak of Death [1,+3]
1658  *   OD_OMIT_INSCRIPTION : The Cloak of Death [1,+3] (+2 to Stealth)
1659  *   0                   : The Cloak of Death [1,+3] (+2 to Stealth) {nifty}
1660  *
1661  *   OD_OMIT_PREFIX      : Forbidden numeric prefix
1662  *   OD_NO_PLURAL        : Forbidden use of plural 
1663  *   OD_STORE            : Assume to be aware and known
1664  *   OD_NO_FLAVOR        : Allow to hidden flavor
1665  */
1666 void object_desc(char *buf, object_type *o_ptr, u32b mode)
1667 {
1668         /* Extract object kind name */
1669         cptr            kindname = k_name + k_info[o_ptr->k_idx].name;
1670
1671         /* Extract default "base" string */
1672         cptr            basenm = kindname;
1673
1674         /* Assume no "modifier" string */
1675         cptr            modstr = "";
1676
1677         /* Hack -- Extract the sub-type "indexx" */
1678         int             indexx = o_ptr->sval;
1679
1680         int             power;
1681
1682         bool            aware = FALSE;
1683         bool            known = FALSE;
1684         bool            flavor = TRUE;
1685
1686         bool            show_weapon = FALSE;
1687         bool            show_armour = FALSE;
1688
1689         cptr            s;
1690         char            *t;
1691
1692         char            p1 = '(', p2 = ')';
1693         char            b1 = '[', b2 = ']';
1694         char            c1 = '{', c2 = '}';
1695
1696         char            tmp_val[MAX_NLEN+160];
1697         char            tmp_val2[MAX_NLEN+10];
1698         char            fake_insc_buf[30];
1699
1700         u32b flgs[TR_FLAG_SIZE];
1701
1702         object_type *bow_ptr;
1703
1704         object_kind *k_ptr = &k_info[o_ptr->k_idx];
1705
1706         /* Extract some flags */
1707         object_flags(o_ptr, flgs);
1708
1709         /* See if the object is "aware" */
1710         if (object_is_aware(o_ptr)) aware = TRUE;
1711
1712         /* See if the object is "known" */
1713         if (object_is_known(o_ptr)) known = TRUE;
1714
1715         /* Allow flavors to be hidden when aware */
1716         if (aware && ((mode & OD_NO_FLAVOR) || plain_descriptions)) flavor = FALSE;
1717
1718         /* Object is in the inventory of a store or spoiler */
1719         if ((mode & OD_STORE) || (o_ptr->ident & IDENT_STORE))
1720         {
1721                 /* Don't show flavors */
1722                 flavor = FALSE;
1723
1724                 /* Pretend known and aware */
1725                 aware = TRUE;
1726                 known = TRUE;
1727         }
1728
1729         /* Analyze the object */
1730         switch (o_ptr->tval)
1731         {
1732                 /* Some objects are easy to describe */
1733                 case TV_SKELETON:
1734                 case TV_BOTTLE:
1735                 case TV_JUNK:
1736                 case TV_SPIKE:
1737                 case TV_FLASK:
1738                 case TV_CHEST:
1739                 case TV_WHISTLE:
1740                 {
1741                         break;
1742                 }
1743
1744                 case TV_CAPTURE:
1745                 {
1746                         monster_race *r_ptr = &r_info[o_ptr->pval];
1747
1748                         if (known)
1749                         {
1750                                 if (!o_ptr->pval)
1751                                 {
1752 #ifdef JP
1753                                         modstr = " (¶õ)";
1754 #else
1755                                         modstr = " (empty)";
1756 #endif
1757                                 }
1758                                 else
1759                                 {
1760 #ifdef JP
1761                                         sprintf(tmp_val2, " (%s)",r_name + r_ptr->name);
1762                                         modstr = tmp_val2;
1763 #else
1764                                         cptr t = r_name + r_ptr->name;
1765
1766                                         if (!(r_ptr->flags1 & RF1_UNIQUE))
1767                                         {
1768                                                 sprintf(tmp_val2, " (%s%s)", (is_a_vowel(*t) ? "an " : "a "), t);
1769
1770                                                 modstr = tmp_val2;
1771                                         }
1772                                         else
1773                                         {
1774                                                 sprintf(tmp_val2, "(%s)", t);
1775
1776                                                 modstr = t;
1777                                         }
1778 #endif
1779                                 }
1780                         }
1781                         break;
1782                 }
1783
1784                 /* Figurines/Statues */
1785                 case TV_FIGURINE:
1786                 case TV_STATUE:
1787                 {
1788                         monster_race *r_ptr = &r_info[o_ptr->pval];
1789
1790 #ifdef JP
1791                         modstr = r_name + r_ptr->name;
1792 #else
1793                         cptr t = r_name + r_ptr->name;
1794
1795                         if (!(r_ptr->flags1 & RF1_UNIQUE))
1796                         {
1797                                 sprintf(tmp_val2, "%s%s", (is_a_vowel(*t) ? "an " : "a "), t);
1798
1799                                 modstr = tmp_val2;
1800                         }
1801                         else
1802                         {
1803                                 modstr = t;
1804                         }
1805 #endif
1806
1807
1808                         break;
1809                 }
1810
1811                 /* Corpses */
1812                 case TV_CORPSE:
1813                 {
1814                         monster_race *r_ptr = &r_info[o_ptr->pval];
1815
1816                         modstr = r_name + r_ptr->name;
1817
1818 #ifdef JP
1819                         basenm = "#%";
1820 #else
1821                         if (r_ptr->flags1 & RF1_UNIQUE)
1822                                 basenm = "& % of #";
1823                         else
1824                                 basenm = "& # %";
1825 #endif
1826
1827                         break;
1828                 }
1829
1830                 /* Missiles/ Bows/ Weapons */
1831                 case TV_SHOT:
1832                 case TV_BOLT:
1833                 case TV_ARROW:
1834                 case TV_BOW:
1835                 case TV_HAFTED:
1836                 case TV_POLEARM:
1837                 case TV_SWORD:
1838                 case TV_DIGGING:
1839                 {
1840                         show_weapon = TRUE;
1841                         break;
1842                 }
1843
1844
1845                 /* Armour */
1846                 case TV_BOOTS:
1847                 case TV_GLOVES:
1848                 case TV_CLOAK:
1849                 case TV_CROWN:
1850                 case TV_HELM:
1851                 case TV_SHIELD:
1852                 case TV_SOFT_ARMOR:
1853                 case TV_HARD_ARMOR:
1854                 case TV_DRAG_ARMOR:
1855                 {
1856                         show_armour = TRUE;
1857                         break;
1858                 }
1859
1860
1861                 /* Lites (including a few "Specials") */
1862                 case TV_LITE:
1863                 {
1864                         break;
1865                 }
1866
1867                 /* Amulets (including a few "Specials") */
1868                 case TV_AMULET:
1869                 {
1870                         /* Known artifacts */
1871                         if (aware)
1872                         {
1873                                 if (object_is_fixed_artifact(o_ptr)) break;
1874                                 if (k_ptr->gen_flags & TRG_INSTA_ART) break;
1875                         }
1876
1877                         /* Color the object */
1878                         modstr = amulet_adj[indexx];
1879
1880 #ifdef JP
1881                         if (!flavor)    basenm = "%¤Î¥¢¥ß¥å¥ì¥Ã¥È";
1882                         else if (aware) basenm = "%¤Î#¥¢¥ß¥å¥ì¥Ã¥È";
1883                         else            basenm = "#¥¢¥ß¥å¥ì¥Ã¥È";
1884 #else
1885                         if (!flavor)    basenm = "& Amulet~ of %";
1886                         else if (aware) basenm = "& # Amulet~ of %";
1887                         else            basenm = "& # Amulet~";
1888 #endif
1889
1890                         break;
1891                 }
1892
1893                 /* Rings (including a few "Specials") */
1894                 case TV_RING:
1895                 {
1896                         /* Known artifacts */
1897                         if (aware)
1898                         {
1899                                 if (object_is_fixed_artifact(o_ptr)) break;
1900                                 if (k_ptr->gen_flags & TRG_INSTA_ART) break;
1901                         }
1902
1903                         /* Color the object */
1904                         modstr = ring_adj[indexx];
1905
1906 #ifdef JP
1907                         if (!flavor)    basenm = "%¤Î»ØÎØ";
1908                         else if (aware) basenm = "%¤Î#»ØÎØ";
1909                         else            basenm = "#»ØÎØ";
1910 #else
1911                         if (!flavor)    basenm = "& Ring~ of %";
1912                         else if (aware) basenm = "& # Ring~ of %";
1913                         else            basenm = "& # Ring~";
1914 #endif
1915
1916                         if (!k_ptr->to_h && !k_ptr->to_d && (o_ptr->to_h || o_ptr->to_d)) show_weapon = TRUE;
1917
1918                         break;
1919                 }
1920
1921                 case TV_CARD:
1922                 {
1923                         break;
1924                 }
1925
1926                 case TV_STAFF:
1927                 {
1928                         /* Color the object */
1929                         modstr = staff_adj[indexx];
1930
1931 #ifdef JP
1932                         if (!flavor)    basenm = "%¤Î¾ó";
1933                         else if (aware) basenm = "%¤Î#¾ó";
1934                         else            basenm = "#¾ó";
1935 #else
1936                         if (!flavor)    basenm = "& Staff~ of %";
1937                         else if (aware) basenm = "& # Staff~ of %";
1938                         else            basenm = "& # Staff~";
1939 #endif
1940
1941                         break;
1942                 }
1943
1944                 case TV_WAND:
1945                 {
1946                         /* Color the object */
1947                         modstr = wand_adj[indexx];
1948
1949 #ifdef JP
1950                         if (!flavor)    basenm = "%¤ÎËâË¡ËÀ";
1951                         else if (aware) basenm = "%¤Î#ËâË¡ËÀ";
1952                         else            basenm = "#ËâË¡ËÀ";
1953 #else
1954                         if (!flavor)    basenm = "& Wand~ of %";
1955                         else if (aware) basenm = "& # Wand~ of %";
1956                         else            basenm = "& # Wand~";
1957 #endif
1958
1959                         break;
1960                 }
1961
1962                 case TV_ROD:
1963                 {
1964                         /* Color the object */
1965                         modstr = rod_adj[indexx];
1966
1967 #ifdef JP
1968                         if (!flavor)    basenm = "%¤Î¥í¥Ã¥É";
1969                         else if (aware) basenm = "%¤Î#¥í¥Ã¥É";
1970                         else            basenm = "#¥í¥Ã¥É";
1971 #else
1972                         if (!flavor)    basenm = "& Rod~ of %";
1973                         else if (aware) basenm = "& # Rod~ of %";
1974                         else            basenm = "& # Rod~";
1975 #endif
1976
1977                         break;
1978                 }
1979
1980                 case TV_SCROLL:
1981                 {
1982                         /* Color the object */
1983                         modstr = scroll_adj[indexx];
1984
1985 #ifdef JP
1986                         if (!flavor)    basenm = "%¤Î´¬Êª";
1987                         else if (aware) basenm = "¡Ö#¡×¤È½ñ¤«¤ì¤¿%¤Î´¬Êª";
1988                         else            basenm = "¡Ö#¡×¤È½ñ¤«¤ì¤¿´¬Êª";
1989 #else
1990                         if (!flavor)    basenm = "& Scroll~ of %";
1991                         else if (aware) basenm = "& Scroll~ titled \"#\" of %";
1992                         else            basenm = "& Scroll~ titled \"#\"";
1993 #endif
1994
1995                         break;
1996                 }
1997
1998                 case TV_POTION:
1999                 {
2000                         /* Color the object */
2001                         modstr = potion_adj[indexx];
2002
2003 #ifdef JP
2004                         if (!flavor)    basenm = "%¤ÎÌô";
2005                         else if (aware) basenm = "%¤Î#Ìô";
2006                         else            basenm = "#Ìô";
2007 #else
2008                         if (!flavor)    basenm = "& Potion~ of %";
2009                         else if (aware) basenm = "& # Potion~ of %";
2010                         else            basenm = "& # Potion~";
2011 #endif
2012
2013                         break;
2014                 }
2015
2016                 case TV_FOOD:
2017                 {
2018                         /* Ordinary food is "boring" */
2019                         if (o_ptr->sval >= SV_FOOD_MIN_FOOD) break;
2020
2021                         /* Color the object */
2022                         modstr = food_adj[indexx];
2023
2024 #ifdef JP
2025                         if (!flavor)    basenm = "%¤Î¥­¥Î¥³";
2026                         else if (aware) basenm = "%¤Î#¥­¥Î¥³";
2027                         else            basenm = "#¥­¥Î¥³";
2028 #else
2029                         if (!flavor)    basenm = "& Mushroom~ of %";
2030                         else if (aware) basenm = "& # Mushroom~ of %";
2031                         else            basenm = "& # Mushroom~";
2032 #endif
2033
2034                         break;
2035                 }
2036
2037                 case TV_PARCHMENT:
2038                 {
2039 #ifdef JP
2040                         basenm = "ÍÓÈé»æ - %";
2041 #else
2042                         basenm = "& Parchment~ - %";
2043 #endif
2044                         break;
2045                 }
2046
2047                 /* Magic Books */
2048                 case TV_LIFE_BOOK:
2049                 {
2050 #ifdef JP
2051                         basenm = "À¸Ì¿¤ÎËâË¡½ñ%";
2052 #else
2053                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2054                                 basenm = "& Book~ of Life Magic %";
2055                         else
2056                                 basenm = "& Life Spellbook~ %";
2057 #endif
2058
2059                         break;
2060                 }
2061
2062                 case TV_SORCERY_BOOK:
2063                 {
2064 #ifdef JP
2065                         basenm = "Àç½Ñ¤ÎËâË¡½ñ%";
2066 #else
2067                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2068                                 basenm = "& Book~ of Sorcery %";
2069                         else
2070                                 basenm = "& Sorcery Spellbook~ %";
2071 #endif
2072
2073                         break;
2074                 }
2075
2076                 case TV_NATURE_BOOK:
2077                 {
2078 #ifdef JP
2079                         basenm = "¼«Á³¤ÎËâË¡½ñ%";
2080 #else
2081                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2082                                 basenm = "& Book~ of Nature Magic %";
2083                         else
2084                                 basenm = "& Nature Spellbook~ %";
2085 #endif
2086
2087                         break;
2088                 }
2089
2090                 case TV_CHAOS_BOOK:
2091                 {
2092 #ifdef JP
2093                         basenm = "¥«¥ª¥¹¤ÎËâË¡½ñ%";
2094 #else
2095                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2096                                 basenm = "& Book~ of Chaos Magic %";
2097                         else
2098                                 basenm = "& Chaos Spellbook~ %";
2099 #endif
2100
2101                         break;
2102                 }
2103
2104                 case TV_DEATH_BOOK:
2105                 {
2106 #ifdef JP
2107                         basenm = "°Å¹õ¤ÎËâË¡½ñ%";
2108 #else
2109                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2110                                 basenm = "& Book~ of Death Magic %";
2111                         else
2112                                 basenm = "& Death Spellbook~ %";
2113 #endif
2114
2115                         break;
2116                 }
2117
2118                 case TV_TRUMP_BOOK:
2119                 {
2120 #ifdef JP
2121                         basenm = "¥È¥é¥ó¥×¤ÎËâË¡½ñ%";
2122 #else
2123                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2124                                 basenm = "& Book~ of Trump Magic %";
2125                         else
2126                                 basenm = "& Trump Spellbook~ %";
2127 #endif
2128
2129                         break;
2130                 }
2131
2132                 case TV_ARCANE_BOOK:
2133                 {
2134 #ifdef JP
2135                         basenm = "Èë½Ñ¤ÎËâË¡½ñ%";
2136 #else
2137                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2138                                 basenm = "& Book~ of Arcane Magic %";
2139                         else
2140                                 basenm = "& Arcane Spellbook~ %";
2141 #endif
2142
2143                         break;
2144                 }
2145
2146                 case TV_ENCHANT_BOOK:
2147                 {
2148 #ifdef JP
2149                         basenm = "¾¢¤ÎËâË¡½ñ%";
2150 #else
2151                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2152                                 basenm = "& Book~ of Craft Magic %";
2153                         else
2154                                 basenm = "& Craft Spellbook~ %";
2155 #endif
2156
2157                         break;
2158                 }
2159
2160                 case TV_DAEMON_BOOK:
2161                 {
2162 #ifdef JP
2163                         basenm = "°­Ëâ¤ÎËâË¡½ñ%";
2164 #else
2165                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2166                                 basenm = "& Book~ of Daemon Magic %";
2167                         else
2168                                 basenm = "& Daemon Spellbook~ %";
2169 #endif
2170
2171                         break;
2172                 }
2173
2174                 case TV_CRUSADE_BOOK:
2175                 {
2176 #ifdef JP
2177                         basenm = "Ç˼٤ÎËâË¡½ñ%";
2178 #else
2179                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2180                                 basenm = "& Book~ of Crusade Magic %";
2181                         else
2182                                 basenm = "& Crusade Spellbook~ %";
2183 #endif
2184
2185                         break;
2186                 }
2187
2188                 case TV_MUSIC_BOOK:
2189                 {
2190 #ifdef JP
2191                         basenm = "²Î½¸%";
2192 #else
2193                         basenm = "& Song Book~ %";
2194 #endif
2195
2196                         break;
2197                 }
2198
2199                 case TV_HISSATSU_BOOK:
2200                 {
2201 #ifdef JP
2202                         basenm = "& Éð·Ý¤Î½ñ%";
2203 #else
2204                         basenm = "Book~ of Kendo %";
2205 #endif
2206
2207                         break;
2208                 }
2209
2210                 /* Hack -- Gold/Gems */
2211                 case TV_GOLD:
2212                 {
2213                         strcpy(buf, basenm);
2214                         return;
2215                 }
2216
2217                 /* Used in the "inventory" routine */
2218                 default:
2219                 {
2220 #ifdef JP
2221                         strcpy(buf, "(¤Ê¤·)");
2222 #else
2223                         strcpy(buf, "(nothing)");
2224 #endif
2225
2226                         return;
2227                 }
2228         }
2229
2230         /* Use full name from k_info or a_info */
2231         if (aware && have_flag(flgs, TR_FULL_NAME))
2232         {
2233                 if (known && o_ptr->name1) basenm = a_name + a_info[o_ptr->name1].name;
2234                 else basenm = kindname;
2235         }
2236
2237         /* Start dumping the result */
2238         t = tmp_val;
2239
2240 #ifdef JP
2241         if (basenm[0] == '&')
2242                 s = basenm + 2;
2243         else
2244                 s = basenm;
2245
2246         /* No prefix */
2247         if (mode & OD_OMIT_PREFIX)
2248         {
2249                 /* Nothing */
2250         }
2251         else if (o_ptr->number > 1)
2252         {
2253                 t = object_desc_kosuu(t, o_ptr);
2254                 t = object_desc_str(t, "¤Î ");
2255         }
2256
2257         /* ±Ñ¸ì¤Î¾ì¹ç¥¢¡¼¥Æ¥£¥Õ¥¡¥¯¥È¤Ï The ¤¬ÉÕ¤¯¤Î¤Çʬ¤«¤ë¤¬
2258          * ÆüËܸì¤Ç¤Ïʬ¤«¤é¤Ê¤¤¤Î¤Ç¥Þ¡¼¥¯¤ò¤Ä¤±¤ë 
2259          */
2260         if (known)
2261         {
2262                 if (object_is_fixed_artifact(o_ptr)) t = object_desc_str(t, "¡ú");
2263                 else if (o_ptr->art_name) t = object_desc_str(t, "¡ù");
2264         }
2265
2266 #else
2267
2268         /* The object "expects" a "number" */
2269         if (basenm[0] == '&')
2270         {
2271                 /* Skip the ampersand (and space) */
2272                 s = basenm + 2;
2273
2274                 /* No prefix */
2275                 if (mode & OD_OMIT_PREFIX)
2276                 {
2277                         /* Nothing */
2278                 }
2279
2280                 /* Hack -- None left */
2281                 else if (o_ptr->number <= 0)
2282                 {
2283                         t = object_desc_str(t, "no more ");
2284                 }
2285
2286                 /* Extract the number */
2287                 else if (o_ptr->number > 1)
2288                 {
2289                         t = object_desc_num(t, o_ptr->number);
2290                         t = object_desc_chr(t, ' ');
2291                 }
2292
2293                 /* Hack -- The only one of its kind */
2294                 else if (known && object_is_artifact(o_ptr))
2295                 {
2296                         t = object_desc_str(t, "The ");
2297                 }
2298
2299                 /* Unique corpses are unique */
2300                 else if (o_ptr->tval == TV_CORPSE)
2301                 {
2302                         monster_race *r_ptr = &r_info[o_ptr->pval];
2303
2304                         if (r_ptr->flags1 & RF1_UNIQUE)
2305                         {
2306                                 t = object_desc_str(t, "The ");
2307                         }
2308                 }
2309
2310                 /* A single one */
2311                 else
2312                 {
2313                         bool vowel;
2314
2315                         switch (*s)
2316                         {
2317                         case '#': vowel = is_a_vowel(modstr[0]); break;
2318                         case '%': vowel = is_a_vowel(*kindname); break;
2319                         default:  vowel = is_a_vowel(*s); break;
2320                         }
2321
2322                         if (vowel)
2323                         {
2324                                 /* A single one, with a vowel */
2325                                 t = object_desc_str(t, "an ");
2326                         }
2327                         else
2328                         {
2329                                 /* A single one, without a vowel */
2330                                 t = object_desc_str(t, "a ");
2331                         }
2332                 }
2333         }
2334
2335         /* Hack -- objects that "never" take an article */
2336         else
2337         {
2338                 /* No ampersand */
2339                 s = basenm;
2340
2341                 /* No pref */
2342                 if (mode & OD_OMIT_PREFIX)
2343                 {
2344                         /* Nothing */
2345                 }
2346
2347                 /* Hack -- all gone */
2348                 else if (o_ptr->number <= 0)
2349                 {
2350                         t = object_desc_str(t, "no more ");
2351                 }
2352
2353                 /* Prefix a number if required */
2354                 else if (o_ptr->number > 1)
2355                 {
2356                         t = object_desc_num(t, o_ptr->number);
2357                         t = object_desc_chr(t, ' ');
2358                 }
2359
2360                 /* Hack -- The only one of its kind */
2361                 else if (known && object_is_artifact(o_ptr))
2362                 {
2363                         t = object_desc_str(t, "The ");
2364                 }
2365
2366                 /* Hack -- single items get no prefix */
2367                 else
2368                 {
2369                         /* Nothing */
2370                 }
2371         }
2372 #endif
2373
2374         /* Paranoia -- skip illegal tildes */
2375         /* while (*s == '~') s++; */
2376
2377 #ifdef JP
2378         if (object_is_smith(o_ptr))
2379         {
2380                 t = object_desc_str(t, format("ÃÃÌê»Õ%s¤Î", player_name));
2381         }
2382
2383         /* ÅÁÀâ¤Î¥¢¥¤¥Æ¥à¡¢Ì¾¤Î¤¢¤ë¥¢¥¤¥Æ¥à¤Î̾Á°¤òÉղ乤ë */
2384         if (known)
2385         {
2386                 /* ¥é¥ó¥À¥à¡¦¥¢¡¼¥Æ¥£¥Õ¥¡¥¯¥È */
2387                 if (o_ptr->art_name)
2388                 {
2389                         cptr temp = quark_str(o_ptr->art_name);
2390
2391                         /* '¡Ø' ¤«¤é»Ï¤Þ¤é¤Ê¤¤ÅÁÀâ¤Î¥¢¥¤¥Æ¥à¤Î̾Á°¤ÏºÇ½é¤ËÉղ乤ë */
2392                         /* ±Ñ¸ìÈǤΥ»¡¼¥Ö¥Õ¥¡¥¤¥ë¤«¤éÍ褿 'of XXX' ¤Ï,¡ÖXXX¤Î¡×¤Èɽ¼¨¤¹¤ë */
2393                         if (strncmp(temp, "of ", 3) == 0)
2394                         {
2395                                 t = object_desc_str(t, &temp[3]);
2396                                 t = object_desc_str(t, "¤Î");
2397                         }
2398                         else if ((strncmp(temp, "¡Ø", 2) != 0) &&
2399                                  (strncmp(temp, "¡Ô", 2) != 0) &&
2400                                  (temp[0] != '\''))
2401                                 t = object_desc_str(t, temp);
2402                 }
2403                 /* ÅÁÀâ¤Î¥¢¥¤¥Æ¥à */
2404                 else if (o_ptr->name1 && !have_flag(flgs, TR_FULL_NAME))
2405                 {
2406                         artifact_type *a_ptr = &a_info[o_ptr->name1];
2407                         /* '¡Ø' ¤«¤é»Ï¤Þ¤é¤Ê¤¤ÅÁÀâ¤Î¥¢¥¤¥Æ¥à¤Î̾Á°¤ÏºÇ½é¤ËÉղ乤ë */
2408                         if (strncmp(a_name + a_ptr->name, "¡Ø", 2) != 0)
2409                         {
2410                                 t = object_desc_str(t, a_name + a_ptr->name);
2411                         }
2412                 }
2413                 /* Ì¾¤Î¤¢¤ë¥¢¥¤¥Æ¥à */
2414                 else if (object_is_ego(o_ptr))
2415                 {
2416                         ego_item_type *e_ptr = &e_info[o_ptr->name2];
2417                         t = object_desc_str(t, e_name + e_ptr->name);
2418                 }
2419         }
2420 #endif
2421
2422         /* Copy the string */
2423         for (; *s; s++)
2424         {
2425                 /* Insert the modifier (flavor) */
2426                 if (*s == '#')
2427                 {
2428                         t = object_desc_str(t, modstr);
2429
2430                         /* Paranoia -- Never append multiple modstr's */
2431                         modstr = "";
2432                 }
2433
2434                 /* Append kind name */
2435                 else if (*s == '%')
2436                 {
2437                         t = object_desc_str(t, kindname);
2438
2439                         /* Paranoia -- Never append multiple kindname's */
2440                         kindname = "";
2441                 }
2442
2443 #ifndef JP
2444                 /* Pluralizer */
2445                 else if (*s == '~')
2446                 {
2447                         /* Add a plural if needed */
2448                         if (!(mode & OD_NO_PLURAL) && (o_ptr->number != 1))
2449                         {
2450                                 char k = t[-1];
2451
2452                                 /* XXX XXX XXX Mega-Hack */
2453
2454                                 /* Hack -- "Cutlass-es" and "Torch-es" */
2455                                 if ((k == 's') || (k == 'h')) *t++ = 'e';
2456
2457                                 /* Add an 's' */
2458                                 *t++ = 's';
2459                         }
2460                 }
2461 #endif
2462
2463                 /* Normal */
2464                 else
2465                 {
2466                         /* Copy */
2467                         *t++ = *s;
2468                 }
2469         }
2470
2471         /* Terminate */
2472         *t = '\0';
2473
2474
2475 #ifdef JP
2476         /* '¡Ø'¤«¤é»Ï¤Þ¤ëÅÁÀâ¤Î¥¢¥¤¥Æ¥à¤Î̾Á°¤ÏºÇ¸å¤ËÉղ乤ë */
2477         if (known)
2478         {
2479                 /* ¥é¥ó¥À¥à¥¢¡¼¥Æ¥£¥Õ¥¡¥¯¥È¤Î̾Á°¤Ï¥»¡¼¥Ö¥Õ¥¡¥¤¥ë¤Ëµ­Ï¿
2480                    ¤µ¤ì¤ë¤Î¤Ç¡¢±Ñ¸ìÈǤÎ̾Á°¤â¤½¤ì¤é¤·¤¯ÊÑ´¹¤¹¤ë */
2481                 if (o_ptr->art_name)
2482                 {
2483                         char temp[256];
2484                         int itemp;
2485                         strcpy(temp, quark_str(o_ptr->art_name));
2486                         /* MEGA HACK by ita */
2487                         if (strncmp(temp, "¡Ø", 2) == 0 ||
2488                             strncmp(temp, "¡Ô", 2) == 0)
2489                                 t = object_desc_str(t, temp);
2490                         else if (temp[0] == '\'')
2491                         {
2492                                 itemp = strlen(temp);
2493                                 temp[itemp - 1] = 0;
2494                                 t = object_desc_str(t, "¡Ø");
2495                                 t = object_desc_str(t, &temp[1]);
2496                                 t = object_desc_str(t, "¡Ù");
2497                         }
2498                 }
2499                 else if (object_is_fixed_artifact(o_ptr))
2500                 {
2501                         artifact_type *a_ptr = &a_info[o_ptr->name1];
2502                         if (strncmp(a_name + a_ptr->name, "¡Ø", 2) == 0)
2503                         {
2504                                 t = object_desc_str(t, a_name + a_ptr->name);
2505                         }
2506                 }
2507                 else if (o_ptr->inscription)
2508                 {
2509                         cptr str = quark_str(o_ptr->inscription);
2510
2511                         while(*str)
2512                         {
2513                                 if (iskanji(*str))
2514                                 {
2515                                         str += 2;
2516                                         continue;
2517                                 }
2518                                 if (*str == '#') break;
2519                                 str++;
2520                         }
2521                         if (*str)
2522                         {
2523                                 /* Find the '#' */
2524                                 cptr str = my_strchr(quark_str(o_ptr->inscription), '#');
2525
2526                                 /* Add the false name */
2527                                 t = object_desc_str(t,"¡Ø");
2528                                 t = object_desc_str(t, &str[1]);
2529                                 t = object_desc_str(t,"¡Ù");
2530                         }
2531                 }
2532         }
2533 #else
2534         if (object_is_smith(o_ptr))
2535         {
2536                 t = object_desc_str(t,format(" of %s the Smith",player_name));
2537         }
2538
2539         /* Hack -- Append "Artifact" or "Special" names */
2540         if (known && !have_flag(flgs, TR_FULL_NAME))
2541         {
2542                 /* Is it a new random artifact ? */
2543                 if (o_ptr->art_name)
2544                 {
2545                         t = object_desc_chr(t, ' ');
2546                         t = object_desc_str(t, quark_str(o_ptr->art_name));
2547                 }
2548
2549                 /* Grab any artifact name */
2550                 else if (object_is_fixed_artifact(o_ptr))
2551                 {
2552                         artifact_type *a_ptr = &a_info[o_ptr->name1];
2553
2554                         t = object_desc_chr(t, ' ');
2555                         t = object_desc_str(t, a_name + a_ptr->name);
2556                 }
2557
2558                 /* Grab any ego-item name */
2559                 else
2560                 {
2561                         if (object_is_ego(o_ptr))
2562                         {
2563                                 ego_item_type *e_ptr = &e_info[o_ptr->name2];
2564
2565                                 t = object_desc_chr(t, ' ');
2566                                 t = object_desc_str(t, e_name + e_ptr->name);
2567                         }
2568
2569                         if (o_ptr->inscription && my_strchr(quark_str(o_ptr->inscription), '#'))
2570                         {
2571                                 /* Find the '#' */
2572                                 cptr str = my_strchr(quark_str(o_ptr->inscription), '#');
2573
2574                                 /* Add the false name */
2575                                 t = object_desc_chr(t, ' ');
2576                                 t = object_desc_str(t, &str[1]);
2577                         }
2578                 }
2579         }
2580 #endif
2581
2582
2583         /* No more details wanted */
2584         if (mode & OD_NAME_ONLY) goto object_desc_done;
2585
2586         /* Hack -- Chests must be described in detail */
2587         if (o_ptr->tval == TV_CHEST)
2588         {
2589                 /* Not searched yet */
2590                 if (!known)
2591                 {
2592                         /* Nothing */
2593                 }
2594
2595                 /* May be "empty" */
2596                 else if (!o_ptr->pval)
2597                 {
2598 #ifdef JP
2599                         t = object_desc_str(t, "(¶õ)");
2600 #else
2601                         t = object_desc_str(t, " (empty)");
2602 #endif
2603                 }
2604
2605                 /* May be "disarmed" */
2606                 else if (o_ptr->pval < 0)
2607                 {
2608                         if (chest_traps[0 - o_ptr->pval])
2609                         {
2610 #ifdef JP
2611                                 t = object_desc_str(t, "(²ò½üºÑ)");
2612 #else
2613                                 t = object_desc_str(t, " (disarmed)");
2614 #endif
2615                         }
2616                         else
2617                         {
2618 #ifdef JP
2619                                 t = object_desc_str(t, "(Èó»Ü¾û)");
2620 #else
2621                                 t = object_desc_str(t, " (unlocked)");
2622 #endif
2623                         }
2624                 }
2625
2626                 /* Describe the traps, if any */
2627                 else
2628                 {
2629                         /* Describe the traps */
2630                         switch (chest_traps[o_ptr->pval])
2631                         {
2632                                 case 0:
2633                                 {
2634 #ifdef JP
2635                                         t = object_desc_str(t, "(»Ü¾û)");
2636 #else
2637                                         t = object_desc_str(t, " (Locked)");
2638 #endif
2639                                         break;
2640                                 }
2641                                 case CHEST_LOSE_STR:
2642                                 {
2643 #ifdef JP
2644                                         t = object_desc_str(t, "(ÆÇ¿Ë)");
2645 #else
2646                                         t = object_desc_str(t, " (Poison Needle)");
2647 #endif
2648                                         break;
2649                                 }
2650                                 case CHEST_LOSE_CON:
2651                                 {
2652 #ifdef JP
2653                                         t = object_desc_str(t, "(ÆÇ¿Ë)");
2654 #else
2655                                         t = object_desc_str(t, " (Poison Needle)");
2656 #endif
2657                                         break;
2658                                 }
2659                                 case CHEST_POISON:
2660                                 {
2661 #ifdef JP
2662                                         t = object_desc_str(t, "(¥¬¥¹¡¦¥È¥é¥Ã¥×)");
2663 #else
2664                                         t = object_desc_str(t, " (Gas Trap)");
2665 #endif
2666                                         break;
2667                                 }
2668                                 case CHEST_PARALYZE:
2669                                 {
2670 #ifdef JP
2671                                         t = object_desc_str(t, "(¥¬¥¹¡¦¥È¥é¥Ã¥×)");
2672 #else
2673                                         t = object_desc_str(t, " (Gas Trap)");
2674 #endif
2675                                         break;
2676                                 }
2677                                 case CHEST_EXPLODE:
2678                                 {
2679 #ifdef JP
2680                                         t = object_desc_str(t, "(ÇúȯÁõÃÖ)");
2681 #else
2682                                         t = object_desc_str(t, " (Explosion Device)");
2683 #endif
2684                                         break;
2685                                 }
2686                                 case CHEST_SUMMON:
2687                                 case CHEST_BIRD_STORM:
2688                                 case CHEST_E_SUMMON:
2689                                 case CHEST_H_SUMMON:
2690                                 {
2691 #ifdef JP
2692                                         t = object_desc_str(t, "(¾¤´­¤Î¥ë¡¼¥ó)");
2693 #else
2694                                         t = object_desc_str(t, " (Summoning Runes)");
2695 #endif
2696                                         break;
2697                                 }
2698                                 case CHEST_RUNES_OF_EVIL:
2699                                 {
2700 #ifdef JP
2701                                         t = object_desc_str(t, "(¼Ù°­¤Ê¥ë¡¼¥ó)");
2702 #else
2703                                         t = object_desc_str(t, " (Gleaming Black Runes)");
2704 #endif
2705                                         break;
2706                                 }
2707                                 case CHEST_ALARM:
2708                                 {
2709 #ifdef JP
2710                                         t = object_desc_str(t, "(·ÙÊóÁõÃÖ)");
2711 #else
2712                                         t = object_desc_str(t, " (Alarm)");
2713 #endif
2714                                         break;
2715                                 }
2716                                 default:
2717                                 {
2718 #ifdef JP
2719                                         t = object_desc_str(t, "(¥Þ¥ë¥Á¡¦¥È¥é¥Ã¥×)");
2720 #else
2721                                         t = object_desc_str(t, " (Multiple Traps)");
2722 #endif
2723                                         break;
2724                                 }
2725                         }
2726                 }
2727         }
2728
2729
2730         /* Display the item like a weapon */
2731         if (have_flag(flgs, TR_SHOW_MODS)) show_weapon = TRUE;
2732
2733         /* Display the item like a weapon */
2734         if (object_is_smith(o_ptr) && (o_ptr->xtra3 == 1 + ESSENCE_SLAY_GLOVE))
2735                 show_weapon = TRUE;
2736
2737         /* Display the item like a weapon */
2738         if (o_ptr->to_h && o_ptr->to_d) show_weapon = TRUE;
2739
2740         /* Display the item like armour */
2741         if (o_ptr->ac) show_armour = TRUE;
2742
2743
2744         /* Dump base weapon info */
2745         switch (o_ptr->tval)
2746         {
2747                 /* Missiles and Weapons */
2748                 case TV_SHOT:
2749                 case TV_BOLT:
2750                 case TV_ARROW:
2751                 case TV_HAFTED:
2752                 case TV_POLEARM:
2753                 case TV_SWORD:
2754                 case TV_DIGGING:
2755
2756                 /* Append a "damage" string */
2757                 t = object_desc_chr(t, ' ');
2758                 t = object_desc_chr(t, p1);
2759                 t = object_desc_num(t, o_ptr->dd);
2760                 t = object_desc_chr(t, 'd');
2761                 t = object_desc_num(t, o_ptr->ds);
2762                 t = object_desc_chr(t, p2);
2763
2764                 /* All done */
2765                 break;
2766
2767
2768                 /* Bows get a special "damage string" */
2769                 case TV_BOW:
2770
2771                 /* Mega-Hack -- Extract the "base power" */
2772                 power = bow_tmul(o_ptr->sval);
2773
2774                 /* Apply the "Extra Might" flag */
2775                 if (have_flag(flgs, TR_XTRA_MIGHT)) power++;
2776
2777                 /* Append a special "damage" string */
2778                 t = object_desc_chr(t, ' ');
2779                 t = object_desc_chr(t, p1);
2780                 t = object_desc_chr(t, 'x');
2781                 t = object_desc_num(t, power);
2782                 t = object_desc_chr(t, p2);
2783
2784                 /* All done */
2785                 break;
2786         }
2787
2788
2789         /* Add the weapon bonuses */
2790         if (known)
2791         {
2792                 /* Show the tohit/todam on request */
2793                 if (show_weapon)
2794                 {
2795                         t = object_desc_chr(t, ' ');
2796                         t = object_desc_chr(t, p1);
2797                         t = object_desc_int(t, o_ptr->to_h);
2798                         t = object_desc_chr(t, ',');
2799                         t = object_desc_int(t, o_ptr->to_d);
2800                         t = object_desc_chr(t, p2);
2801                 }
2802
2803                 /* Show the tohit if needed */
2804                 else if (o_ptr->to_h)
2805                 {
2806                         t = object_desc_chr(t, ' ');
2807                         t = object_desc_chr(t, p1);
2808                         t = object_desc_int(t, o_ptr->to_h);
2809                         t = object_desc_chr(t, p2);
2810                 }
2811
2812                 /* Show the todam if needed */
2813                 else if (o_ptr->to_d)
2814                 {
2815                         t = object_desc_chr(t, ' ');
2816                         t = object_desc_chr(t, p1);
2817                         t = object_desc_int(t, o_ptr->to_d);
2818                         t = object_desc_chr(t, p2);
2819                 }
2820         }
2821
2822         bow_ptr = &inventory[INVEN_BOW];
2823
2824         /* If have a firing weapon + ammo matches bow */
2825         if (bow_ptr->k_idx && (o_ptr->tval == p_ptr->tval_ammo))
2826         {
2827                 int avgdam = o_ptr->dd * (o_ptr->ds + 1) * 10 / 2;
2828                 int tmul = bow_tmul(bow_ptr->sval);
2829                 s16b energy_fire = bow_energy(bow_ptr->sval);
2830
2831                 /* See if the bow is "known" - then set damage bonus */
2832                 if (object_is_known(bow_ptr)) avgdam += (bow_ptr->to_d * 10);
2833
2834                 /* Effect of ammo */
2835                 if (known) avgdam += (o_ptr->to_d * 10);
2836
2837                 /* Get extra "power" from "extra might" */
2838                 if (p_ptr->xtra_might) tmul++;
2839
2840                 tmul = tmul * (100 + (int)(adj_str_td[p_ptr->stat_ind[A_STR]]) - 128);
2841
2842                 /* Launcher multiplier */
2843                 avgdam *= tmul;
2844                 avgdam /= (100 * 10);
2845                 if (avgdam < 0) avgdam = 0;
2846
2847                 /* Display (shot damage/ avg damage) */
2848                 t = object_desc_chr(t, ' ');
2849                 t = object_desc_chr(t, p1);
2850                 t = object_desc_num(t, avgdam);
2851                 t = object_desc_chr(t, '/');
2852
2853                 if (p_ptr->num_fire == 0)
2854                 {
2855                         t = object_desc_chr(t, '0');
2856                 }
2857                 else
2858                 {
2859                         /* Calc effects of energy */
2860                         avgdam *= (p_ptr->num_fire * 100);
2861                         avgdam /= energy_fire;
2862                         t = object_desc_num(t, avgdam);
2863                 }
2864
2865                 t = object_desc_chr(t, p2);
2866         }
2867         else if ((p_ptr->pclass == CLASS_NINJA) && (o_ptr->tval == TV_SPIKE))
2868         {
2869                 int avgdam = p_ptr->mighty_throw ? (1 + 3) : 1;
2870                 s16b energy_fire = 100 - p_ptr->lev;
2871
2872                 avgdam += ((p_ptr->lev + 30) * (p_ptr->lev + 30) - 900) / 55;
2873
2874                 /* Display (shot damage/ avg damage) */
2875                 t = object_desc_chr(t, ' ');
2876                 t = object_desc_chr(t, p1);
2877                 t = object_desc_num(t, avgdam);
2878                 t = object_desc_chr(t, '/');
2879
2880                 /* Calc effects of energy */
2881                 avgdam = 100 * avgdam / energy_fire;
2882
2883                 t = object_desc_num(t, avgdam);
2884                 t = object_desc_chr(t, p2);
2885         }
2886
2887         /* Add the armor bonuses */
2888         if (known)
2889         {
2890                 /* Show the armor class info */
2891                 if (show_armour)
2892                 {
2893                         t = object_desc_chr(t, ' ');
2894                         t = object_desc_chr(t, b1);
2895                         t = object_desc_num(t, o_ptr->ac);
2896                         t = object_desc_chr(t, ',');
2897                         t = object_desc_int(t, o_ptr->to_a);
2898                         t = object_desc_chr(t, b2);
2899                 }
2900
2901                 /* No base armor, but does increase armor */
2902                 else if (o_ptr->to_a)
2903                 {
2904                         t = object_desc_chr(t, ' ');
2905                         t = object_desc_chr(t, b1);
2906                         t = object_desc_int(t, o_ptr->to_a);
2907                         t = object_desc_chr(t, b2);
2908                 }
2909         }
2910
2911         /* Hack -- always show base armor */
2912         else if (show_armour)
2913         {
2914                 t = object_desc_chr(t, ' ');
2915                 t = object_desc_chr(t, b1);
2916                 t = object_desc_num(t, o_ptr->ac);
2917                 t = object_desc_chr(t, b2);
2918         }
2919
2920
2921         /* No more details wanted */
2922         if (mode & OD_NAME_AND_ENCHANT) goto object_desc_done;
2923
2924
2925         if (known) /* Known item only */
2926         {
2927                 /*
2928                  * Hack -- Wands and Staffs have charges.  Make certain how many charges
2929                  * a stack of staffs really has is clear. -LM-
2930                  */
2931                 if (((o_ptr->tval == TV_STAFF) || (o_ptr->tval == TV_WAND)))
2932                 {
2933                         /* Dump " (N charges)" */
2934                         t = object_desc_chr(t, ' ');
2935                         t = object_desc_chr(t, p1);
2936
2937                         /* Clear explaination for staffs. */
2938                         if ((o_ptr->tval == TV_STAFF) && (o_ptr->number > 1))
2939                         {
2940                                 t = object_desc_num(t, o_ptr->number);
2941                                 t = object_desc_str(t, "x ");
2942                         }
2943                         t = object_desc_num(t, o_ptr->pval);
2944 #ifdef JP
2945                         t = object_desc_str(t, "²óʬ");
2946 #else
2947                         t = object_desc_str(t, " charge");
2948                         if (o_ptr->pval != 1) t = object_desc_chr(t, 's');
2949 #endif
2950
2951                         t = object_desc_chr(t, p2);
2952                 }
2953                 /* Hack -- Rods have a "charging" indicator.  Now that stacks of rods may
2954                  * be in any state of charge or discharge, this now includes a number. -LM-
2955                  */
2956                 else if (o_ptr->tval == TV_ROD)
2957                 {
2958                         /* Hack -- Dump " (# charging)" if relevant */
2959                         if (o_ptr->timeout)
2960                         {
2961                                 /* Stacks of rods display an exact count of charging rods. */
2962                                 if (o_ptr->number > 1)
2963                                 {
2964                                         /* Paranoia. */
2965                                         if (k_ptr->pval == 0) k_ptr->pval = 1;
2966
2967                                         /* Find out how many rods are charging, by dividing
2968                                          * current timeout by each rod's maximum timeout.
2969                                          * Ensure that any remainder is rounded up.  Display
2970                                          * very discharged stacks as merely fully discharged.
2971                                          */
2972                                         power = (o_ptr->timeout + (k_ptr->pval - 1)) / k_ptr->pval;
2973                                         if (power > o_ptr->number) power = o_ptr->number;
2974
2975                                         /* Display prettily. */
2976                                         t = object_desc_str(t, " (");
2977                                         t = object_desc_num(t, power);
2978 #ifdef JP
2979                                         t = object_desc_str(t, "ËÜ ½¼Å¶Ãæ)");
2980 #else
2981                                         t = object_desc_str(t, " charging)");
2982 #endif
2983                                 }
2984
2985                                 /* "one Rod of Perception (1 charging)" would look tacky. */
2986                                 else
2987                                 {
2988 #ifdef JP
2989                                         t = object_desc_str(t, "(½¼Å¶Ãæ)");
2990 #else
2991                                         t = object_desc_str(t, " (charging)");
2992 #endif
2993                                 }
2994                         }
2995                 }
2996
2997                 /* Dump "pval" flags for wearable items */
2998                 if (have_pval_flags(flgs))
2999                 {
3000                         /* Start the display */
3001                         t = object_desc_chr(t, ' ');
3002                         t = object_desc_chr(t, p1);
3003
3004                         /* Dump the "pval" itself */
3005                         t = object_desc_int(t, o_ptr->pval);
3006
3007                         /* Do not display the "pval" flags */
3008                         if (have_flag(flgs, TR_HIDE_TYPE))
3009                         {
3010                                 /* Nothing */
3011                         }
3012
3013                         /* Speed */
3014                         else if (have_flag(flgs, TR_SPEED))
3015                         {
3016                                 /* Dump " to speed" */
3017 #ifdef JP
3018                                 t = object_desc_str(t, "²Ã®");
3019 #else
3020                                 t = object_desc_str(t, " to speed");
3021 #endif
3022                         }
3023
3024                         /* Attack speed */
3025                         else if (have_flag(flgs, TR_BLOWS))
3026                         {
3027                                 /* Add " attack" */
3028 #ifdef JP
3029                                 t = object_desc_str(t, "¹¶·â");
3030 #else
3031                                 t = object_desc_str(t, " attack");
3032
3033                                 /* Add "attacks" */
3034                                 if (ABS(o_ptr->pval) != 1) t = object_desc_chr(t, 's');
3035 #endif
3036                         }
3037
3038                         /* Stealth */
3039                         else if (have_flag(flgs, TR_STEALTH))
3040                         {
3041                                 /* Dump " to stealth" */
3042 #ifdef JP
3043                                 t = object_desc_str(t, "±£Ì©");
3044 #else
3045                                 t = object_desc_str(t, " to stealth");
3046 #endif
3047                         }
3048
3049                         /* Search */
3050                         else if (have_flag(flgs, TR_SEARCH))
3051                         {
3052                                 /* Dump " to searching" */
3053 #ifdef JP
3054                                 t = object_desc_str(t, "õº÷");
3055 #else
3056                                 t = object_desc_str(t, " to searching");
3057 #endif
3058                         }
3059
3060                         /* Infravision */
3061                         else if (have_flag(flgs, TR_INFRA))
3062                         {
3063                                 /* Dump " to infravision" */
3064 #ifdef JP
3065                                 t = object_desc_str(t, "ÀÖ³°Àþ»ëÎÏ");
3066 #else
3067                                 t = object_desc_str(t, " to infravision");
3068 #endif
3069                         }
3070
3071                         /* Finish the display */
3072                         t = object_desc_chr(t, p2);
3073                 }
3074
3075                 /* Hack -- Process Lanterns/Torches */
3076                 if ((o_ptr->tval == TV_LITE) && (!(object_is_fixed_artifact(o_ptr) || (o_ptr->sval == SV_LITE_FEANOR))))
3077                 {
3078                         /* Hack -- Turns of light for normal lites */
3079 #ifdef JP
3080                         t = object_desc_chr(t, '(');
3081 #else
3082                         t = object_desc_str(t, " (with ");
3083 #endif
3084
3085                         if (o_ptr->name2 == EGO_LITE_LONG) t = object_desc_num(t, o_ptr->xtra4 * 2);
3086                         else t = object_desc_num(t, o_ptr->xtra4);
3087 #ifdef JP
3088                         t = object_desc_str(t, "¥¿¡¼¥ó¤Î¼÷Ì¿)");
3089 #else
3090                         t = object_desc_str(t, " turns of light)");
3091 #endif
3092                 }
3093
3094                 /* Indicate charging objects, but not rods. */
3095                 if (o_ptr->timeout && (o_ptr->tval != TV_ROD))
3096                 {
3097                         /* Hack -- Dump " (charging)" if relevant */
3098 #ifdef JP
3099                         t = object_desc_str(t, "(½¼Å¶Ãæ)");
3100 #else
3101                         t = object_desc_str(t, " (charging)");
3102 #endif
3103                 }
3104         }
3105
3106
3107         /* No more details wanted */
3108         if (mode & OD_OMIT_INSCRIPTION) goto object_desc_done;
3109
3110
3111         /* Prepare real inscriptions in a buffer */
3112         tmp_val2[0] = '\0';
3113
3114         /* Auto abbreviation inscribe */
3115         if ((abbrev_extra || abbrev_all) && (o_ptr->ident & IDENT_MENTAL))
3116         {
3117                 if (!o_ptr->inscription || !my_strchr(quark_str(o_ptr->inscription), '%'))
3118                 {
3119                         bool kanji, all;
3120
3121 #ifdef JP
3122                         kanji = TRUE;
3123 #else
3124                         kanji = FALSE;
3125 #endif
3126                         all = abbrev_all;
3127
3128                         get_ability_abbreviation(tmp_val2, o_ptr, kanji, all);
3129                 }
3130         }
3131
3132         /* Use the standard inscription if available */
3133         if (o_ptr->inscription)
3134         {
3135                 char buff[1024];
3136
3137                 if (tmp_val2[0]) strcat(tmp_val2, ", ");
3138
3139                 /* Get inscription and convert {%} */
3140                 get_inscription(buff, o_ptr);
3141
3142                 /* strcat with correct treating of kanji */
3143                 my_strcat(tmp_val2, buff, sizeof(tmp_val2));
3144         }
3145
3146
3147         /* No fake inscription yet */
3148         fake_insc_buf[0] = '\0';
3149
3150         /* Use the game-generated "feeling" otherwise, if available */
3151         if (o_ptr->feeling)
3152         {
3153                 strcpy(fake_insc_buf, game_inscriptions[o_ptr->feeling]);
3154         }
3155
3156         /* Note "cursed" if the item is known to be cursed */
3157         else if (object_is_cursed(o_ptr) && (known || (o_ptr->ident & IDENT_SENSE)))
3158         {
3159 #ifdef JP
3160                 strcpy(fake_insc_buf, "¼ö¤ï¤ì¤Æ¤¤¤ë");
3161 #else
3162                 strcpy(fake_insc_buf, "cursed");
3163 #endif
3164         }
3165
3166         /* Note "unidentified" if the item is unidentified */
3167         else if (((o_ptr->tval == TV_RING) || (o_ptr->tval == TV_AMULET)
3168                    || (o_ptr->tval == TV_LITE) || (o_ptr->tval == TV_FIGURINE))
3169                  && aware && !known
3170                  && !(o_ptr->ident & IDENT_SENSE))
3171         {
3172 #ifdef JP
3173                 strcpy(fake_insc_buf, "̤´ÕÄê");
3174 #else
3175                 strcpy(fake_insc_buf, "unidentified");
3176 #endif
3177         }
3178
3179         /* Mega-Hack -- note empty wands/staffs */
3180         else if (!known && (o_ptr->ident & IDENT_EMPTY))
3181         {
3182 #ifdef JP
3183                 strcpy(fake_insc_buf, "¶õ");
3184 #else
3185                 strcpy(fake_insc_buf, "empty");
3186 #endif
3187         }
3188
3189         /* Note "tried" if the object has been tested unsuccessfully */
3190         else if (!aware && object_is_tried(o_ptr))
3191         {
3192 #ifdef JP
3193                 strcpy(fake_insc_buf, "̤ȽÌÀ");
3194 #else
3195                 strcpy(fake_insc_buf, "tried");
3196 #endif
3197         }
3198
3199         /* Note the discount, if any */
3200         if (o_ptr->discount)
3201         {
3202                 /* Hidden by real inscription unless in a store */
3203                 if (!tmp_val2[0] || (o_ptr->ident & IDENT_STORE))
3204                 {
3205                         /* Append to other fake inscriptions if any */
3206                         if (fake_insc_buf[0]) strcat(fake_insc_buf, ", ");
3207
3208                         (void)object_desc_num(fake_insc_buf, o_ptr->discount);
3209 #ifdef JP
3210                         strcat(fake_insc_buf, "%°ú¤­");
3211 #else
3212                         strcat(fake_insc_buf, "% off");
3213 #endif
3214                 }
3215         }
3216
3217
3218         /* Append the inscription, if any */
3219         if (fake_insc_buf[0] || tmp_val2[0])
3220         {
3221                 /* Append the inscription */
3222                 t = object_desc_chr(t, ' ');
3223                 t = object_desc_chr(t, c1);
3224
3225                 /* Append fake inscriptions */
3226                 if (fake_insc_buf[0])
3227                 {
3228                         t = object_desc_str(t, fake_insc_buf);
3229                 }
3230
3231                 /* Append a separater */
3232                 if (fake_insc_buf[0] && tmp_val2[0])
3233                 {
3234                         t = object_desc_chr(t, ',');
3235                         t = object_desc_chr(t, ' ');
3236                 }
3237
3238                 /* Append real inscriptions */
3239                 if (tmp_val2[0])
3240                 {
3241                         t = object_desc_str(t, tmp_val2);
3242                 }
3243
3244                 t = object_desc_chr(t, c2);
3245         }
3246
3247 object_desc_done:
3248         my_strcpy(buf, tmp_val, MAX_NLEN);
3249 }
3250
3251
変愚蛮怒のメインリポジトリです
About OSDN
Find Software
Develop Software
Help