Guest User

objnam.c with markup

a guest
Nov 15th, 2026
4
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 401.99 KB | None | 0 0
  1. Below is the full text to '''objnam.c''' from the [[NetHack 5.0.0 source code|source code]] of [[NetHack 5.0.0]]. To link to a particular line, write [[Source:NetHack 5.0.0/src/objnam.c#line12|<nowiki>[[Source:NetHack 5.0.0/src/objnam.c#line12]]</nowiki>]], for example.
  2.  
  3. {{NGPL}}
  4.  
  5. <span id="line1">1. /* NetHack 5.0 objnam.c $NHDT-Date: 1745114235 2025/04/19 17:57:15 $ $NHDT-Branch: NetHack-3.7 $:$NHDT-Revision: 1.453 $ */</span>
  6. <span id="line2">2. /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */</span>
  7. <span id="line3">3. /*-Copyright (c) Robert Patrick Rankin, 2011. */</span>
  8. <span id="line4">4. /* NetHack may be freely redistributed. See license for details. */</span>
  9. <span id="line5">5. </span>
  10. <span id="line6">6. #include "hack.h"</span>
  11. <span id="line7">7. </span>
  12. <span id="line8">8. /* "an uncursed greased partly eaten guardian naga hatchling [corpse]" */</span>
  13. <span id="line9">9. #define PREFIX 80 /* (56) */</span>
  14. <span id="line10">10. #define SCHAR_LIM 127</span>
  15. <span id="line11">11. #define NUMOBUF 12</span>
  16. <span id="line12">12. </span>
  17. <span id="line13">13. struct _readobjnam_data {</span>
  18. <span id="line14">14. struct obj *otmp;</span>
  19. <span id="line15">15. char *bp;</span>
  20. <span id="line16">16. char *origbp;</span>
  21. <span id="line17">17. char oclass;</span>
  22. <span id="line18">18. char *un, *dn, *actualn;</span>
  23. <span id="line19">19. const char *name;</span>
  24. <span id="line20">20. char *p;</span>
  25. <span id="line21">21. int cnt, spe, spesgn, typ, very, rechrg;</span>
  26. <span id="line22">22. int blessed, uncursed, iscursed, ispoisoned, isgreased;</span>
  27. <span id="line23">23. int eroded, eroded2, erodeproof, locked, unlocked, broken, real, fake;</span>
  28. <span id="line24">24. int halfeaten, mntmp, contents;</span>
  29. <span id="line25">25. int islit, unlabeled, ishistoric, isdiluted, trapped;</span>
  30. <span id="line26">26. int doorless, open, closed, looted;</span>
  31. <span id="line27">27. int tmp, tinv, tvariety, mgend;</span>
  32. <span id="line28">28. int wetness, gsize;</span>
  33. <span id="line29">29. int ftype;</span>
  34. <span id="line30">30. boolean zombify;</span>
  35. <span id="line31">31. char globbuf[BUFSZ];</span>
  36. <span id="line32">32. char fruitbuf[BUFSZ];</span>
  37. <span id="line33">33. };</span>
  38. <span id="line34">34. </span>
  39. <span id="line35">35. staticfn char *strprepend(char *, const char *) NONNULL NONNULLARG1;</span>
  40. <span id="line36">36. staticfn char *nextobuf(void) NONNULL;</span>
  41. <span id="line37">37. staticfn void releaseobuf(char *) NONNULLARG1;</span>
  42. <span id="line38">38. staticfn void xcalled(char *, int, const char *, const char *);</span>
  43. <span id="line39">39. staticfn char *xname_flags(struct obj *, unsigned);</span>
  44. <span id="line40">40. staticfn char *minimal_xname(struct obj *);</span>
  45. <span id="line41">41. staticfn void add_erosion_words(struct obj *, char *);</span>
  46. <span id="line42">42. staticfn char *doname_base(struct obj *obj, unsigned);</span>
  47. <span id="line43">43. staticfn boolean singplur_lookup(char *, char *, boolean,</span>
  48. <span id="line44">44. const char *const *);</span>
  49. <span id="line45">45. staticfn char *singplur_compound(char *);</span>
  50. <span id="line46">46. staticfn boolean ch_ksound(const char *basestr);</span>
  51. <span id="line47">47. staticfn boolean badman(const char *, boolean);</span>
  52. <span id="line48">48. staticfn boolean wishymatch(const char *, const char *, boolean);</span>
  53. <span id="line49">49. staticfn short rnd_otyp_by_wpnskill(schar);</span>
  54. <span id="line50">50. staticfn short rnd_otyp_by_namedesc(const char *, char, int);</span>
  55. <span id="line51">51. staticfn void set_wallprop_from_str(char *) NONNULLARG1;</span>
  56. <span id="line52">52. staticfn struct obj *wizterrainwish(struct _readobjnam_data *);</span>
  57. <span id="line53">53. staticfn void dbterrainmesg(const char *, coordxy, coordxy) NONNULLARG1;</span>
  58. <span id="line54">54. staticfn void readobjnam_init(char *, struct _readobjnam_data *);</span>
  59. <span id="line55">55. staticfn int readobjnam_preparse(struct _readobjnam_data *);</span>
  60. <span id="line56">56. staticfn void readobjnam_parse_charges(struct _readobjnam_data *);</span>
  61. <span id="line57">57. staticfn int readobjnam_postparse1(struct _readobjnam_data *);</span>
  62. <span id="line58">58. staticfn int readobjnam_postparse2(struct _readobjnam_data *);</span>
  63. <span id="line59">59. staticfn int readobjnam_postparse3(struct _readobjnam_data *);</span>
  64. <span id="line60">60. </span>
  65. <span id="line61">61. struct Jitem {</span>
  66. <span id="line62">62. int item;</span>
  67. <span id="line63">63. const char *name;</span>
  68. <span id="line64">64. };</span>
  69. <span id="line65">65. </span>
  70. <span id="line66">66. #define BSTRCMPI(base, ptr, str) ((ptr) < base || strcmpi((ptr), str))</span>
  71. <span id="line67">67. #define BSTRNCMPI(base, ptr, str, num) \</span>
  72. <span id="line68">68. ((ptr) < base || strncmpi((ptr), str, num))</span>
  73. <span id="line69">69. #define Strcasecpy(dst, src) (void) strcasecpy(dst, src)</span>
  74. <span id="line70">70. #define Strncat(dst, src, cnt) (void) strncat(dst, src, cnt)</span>
  75. <span id="line71">71. </span>
  76. <span id="line72">72. /* Concat(): append text to base, adjusted by delta, with bounds checking</span>
  77. <span id="line73">73. via a pair of behind-the-scenes variables; delta is either 0 for normal</span>
  78. <span id="line74">74. concatenation or 1 to replace the final character with something */</span>
  79. <span id="line75">75. #define Concat(base, delta, text) \</span>
  80. <span id="line76">76. do { \</span>
  81. <span id="line77">77. Strncat(base ## _eos - delta, text, base ## spaceleft + delta); \</span>
  82. <span id="line78">78. ConcUpdate(base); \</span>
  83. <span id="line79">79. } while (0)</span>
  84. <span id="line80">80. #define ConcatF1(base, delta, fmt, arg1) \</span>
  85. <span id="line81">81. do { \</span>
  86. <span id="line82">82. Snprintf(base ## _eos - delta, base ## spaceleft + delta, \</span>
  87. <span id="line83">83. fmt, arg1); \</span>
  88. <span id="line84">84. ConcUpdate(base); \</span>
  89. <span id="line85">85. } while (0)</span>
  90. <span id="line86">86. #define ConcatF2(base, delta, fmt, arg1, arg2) \</span>
  91. <span id="line87">87. do { \</span>
  92. <span id="line88">88. Snprintf(base ## _eos - delta, base ## spaceleft + delta, \</span>
  93. <span id="line89">89. fmt, arg1, arg2); \</span>
  94. <span id="line90">90. ConcUpdate(base); \</span>
  95. <span id="line91">91. } while (0)</span>
  96. <span id="line92">92. #define ConcUpdate(base) \</span>
  97. <span id="line93">93. base ## _eos = eos(base), \</span>
  98. <span id="line94">94. /* convert signed ptrdiff_t to unsigned size_t */ \</span>
  99. <span id="line95">95. base ## spaceleft = (size_t) (base ## _end - base ## _eos)</span>
  100. <span id="line96">96. </span>
  101. <span id="line97">97. /* true for gems/rocks that should have " stone" appended to their names */</span>
  102. <span id="line98">98. #define GemStone(typ) \</span>
  103. <span id="line99">99. (typ == FLINT \</span>
  104. <span id="line100">100. || (objects[typ].oc_material == GEMSTONE \</span>
  105. <span id="line101">101. && (typ != DILITHIUM_CRYSTAL && typ != RUBY && typ != DIAMOND \</span>
  106. <span id="line102">102. && typ != SAPPHIRE && typ != BLACK_OPAL && typ != EMERALD \</span>
  107. <span id="line103">103. && typ != OPAL)))</span>
  108. <span id="line104">104. </span>
  109. <span id="line105">105. static const struct Jitem Japanese_items[] = {</span>
  110. <span id="line106">106. { SHORT_SWORD, "wakizashi" },</span>
  111. <span id="line107">107. { BROADSWORD, "ninja-to" },</span>
  112. <span id="line108">108. { FLAIL, "nunchaku" },</span>
  113. <span id="line109">109. { GLAIVE, "naginata" },</span>
  114. <span id="line110">110. { LOCK_PICK, "osaku" },</span>
  115. <span id="line111">111. { WOODEN_HARP, "koto" },</span>
  116. <span id="line112">112. { MAGIC_HARP, "magic koto" },</span>
  117. <span id="line113">113. { KNIFE, "shito" },</span>
  118. <span id="line114">114. { PLATE_MAIL, "tanko" },</span>
  119. <span id="line115">115. { HELMET, "kabuto" },</span>
  120. <span id="line116">116. { LEATHER_GLOVES, "yugake" },</span>
  121. <span id="line117">117. { FOOD_RATION, "gunyoki" },</span>
  122. <span id="line118">118. { POT_BOOZE, "sake" },</span>
  123. <span id="line119">119. { 0, "" }</span>
  124. <span id="line120">120. };</span>
  125. <span id="line121">121. </span>
  126. <span id="line122">122. staticfn char *</span>
  127. <span id="line123">123. strprepend(char *s, const char *pref)</span>
  128. <span id="line124">124. {</span>
  129. <span id="line125">125. char star_s = *s;</span>
  130. <span id="line126">126. int i = (int) strlen(pref);</span>
  131. <span id="line127">127. </span>
  132. <span id="line128">128. if (i > PREFIX) {</span>
  133. <span id="line129">129. impossible("PREFIX too short (for %d).", i);</span>
  134. <span id="line130">130. return s;</span>
  135. <span id="line131">131. }</span>
  136. <span id="line132">132. copynchars(s - i, pref, i + 1);</span>
  137. <span id="line133">133. *s = star_s;</span>
  138. <span id="line134">134. return s - i;</span>
  139. <span id="line135">135. }</span>
  140. <span id="line136">136. </span>
  141. <span id="line137">137. /* manage a pool of BUFSZ buffers, so callers don't have to */</span>
  142. <span id="line138">138. static char NEARDATA obufs[NUMOBUF][BUFSZ];</span>
  143. <span id="line139">139. static int obufidx = 0;</span>
  144. <span id="line140">140. </span>
  145. <span id="line141">141. staticfn char *</span>
  146. <span id="line142">142. nextobuf(void)</span>
  147. <span id="line143">143. {</span>
  148. <span id="line144">144. obufidx = (obufidx + 1) % NUMOBUF;</span>
  149. <span id="line145">145. return obufs[obufidx];</span>
  150. <span id="line146">146. }</span>
  151. <span id="line147">147. </span>
  152. <span id="line148">148. /* put the most recently allocated buffer back if possible */</span>
  153. <span id="line149">149. staticfn void</span>
  154. <span id="line150">150. releaseobuf(char *bufp)</span>
  155. <span id="line151">151. {</span>
  156. <span id="line152">152. /* caller may not know whether bufp is the most recently allocated</span>
  157. <span id="line153">153. buffer; if it isn't, do nothing; note that because of the somewhat</span>
  158. <span id="line154">154. obscure PREFIX handling for object name formatting by xname(),</span>
  159. <span id="line155">155. the pointer our caller has and is passing to us might be into the</span>
  160. <span id="line156">156. middle of an obuf rather than the address returned by nextobuf() */</span>
  161. <span id="line157">157. if (bufp >= obufs[obufidx]</span>
  162. <span id="line158">158. && bufp < obufs[obufidx] + sizeof obufs[obufidx]) /* obufs[][BUFSZ] */</span>
  163. <span id="line159">159. obufidx = (obufidx - 1 + NUMOBUF) % NUMOBUF;</span>
  164. <span id="line160">160. }</span>
  165. <span id="line161">161. </span>
  166. <span id="line162">162. /* used by display_pickinv (invent.c, main whole-inventory routine) to</span>
  167. <span id="line163">163. release each successive doname() result in order to try to avoid</span>
  168. <span id="line164">164. clobbering all the obufs when 'perm_invent' is enabled and updated</span>
  169. <span id="line165">165. while one or more obufs have been allocated but not released yet */</span>
  170. <span id="line166">166. void</span>
  171. <span id="line167">167. maybereleaseobuf(char *obuffer)</span>
  172. <span id="line168">168. {</span>
  173. <span id="line169">169. releaseobuf(obuffer);</span>
  174. <span id="line170">170. </span>
  175. <span id="line171">171. /*</span>
  176. <span id="line172">172. * An example from 3.6.x where all obufs got clobbered was when a</span>
  177. <span id="line173">173. * monster used a bullwhip to disarm the hero of a two-handed weapon:</span>
  178. <span id="line174">174. * "The ogre lord yanks Cleaver from your corpses!"</span>
  179. <span id="line175">175. |</span>
  180. <span id="line176">176. | hand = body_part(HAND);</span>
  181. <span id="line177">177. | if (use_plural) // switches 'hand' from static buffer to an obuf</span>
  182. <span id="line178">178. | hand = makeplural(hand);</span>
  183. <span id="line179">179. ...</span>
  184. <span id="line180">180. | release_worn_item(); // triggers full inventory update for perm_invent</span>
  185. <span id="line181">181. ...</span>
  186. <span id="line182">182. | pline(..., hand); // the obuf[] for "hands" was clobbered with the</span>
  187. <span id="line183">183. | //+ partial formatting of an item from invent</span>
  188. <span id="line184">184. *</span>
  189. <span id="line185">185. * Another example was from writing a scroll without room in invent to</span>
  190. <span id="line186">186. * hold it after being split from a stack of blank scrolls:</span>
  191. <span id="line187">187. * "Oops! food rations out of your grasp!"</span>
  192. <span id="line188">188. * hold_another_object() was passed 'the(aobjnam(newscroll, "slip"))'</span>
  193. <span id="line189">189. * as an argument and that should have yielded</span>
  194. <span id="line190">190. * "Oops! The scroll of <foo> slips out of your grasp!"</span>
  195. <span id="line191">191. * but attempting to add the item to inventory triggered update for</span>
  196. <span id="line192">192. * perm_invent and the result from 'the(...)' was clobbered by partial</span>
  197. <span id="line193">193. * formatting of some inventory item. [It happened in a shop and the</span>
  198. <span id="line194">194. * shk claimed ownership of the new scroll, but that wasn't relevant.]</span>
  199. <span id="line195">195. * That got fixed earlier, by delaying update_inventory() during</span>
  200. <span id="line196">196. * hold_another_object() rather than by avoiding using all the obufs.</span>
  201. <span id="line197">197. */</span>
  202. <span id="line198">198. }</span>
  203. <span id="line199">199. </span>
  204. <span id="line200">200. char *</span>
  205. <span id="line201">201. obj_typename(int otyp)</span>
  206. <span id="line202">202. {</span>
  207. <span id="line203">203. char *buf = nextobuf();</span>
  208. <span id="line204">204. struct objclass *ocl = &objects[otyp];</span>
  209. <span id="line205">205. const char *actualn = OBJ_NAME(*ocl);</span>
  210. <span id="line206">206. const char *dn = OBJ_DESCR(*ocl);</span>
  211. <span id="line207">207. const char *un = ocl->oc_uname;</span>
  212. <span id="line208">208. int nn = ocl->oc_name_known;</span>
  213. <span id="line209">209. </span>
  214. <span id="line210">210. if (Role_if(PM_SAMURAI)) {</span>
  215. <span id="line211">211. actualn = Japanese_item_name(otyp, actualn);</span>
  216. <span id="line212">212. if (otyp == WOODEN_HARP || otyp == MAGIC_HARP)</span>
  217. <span id="line213">213. dn = "koto";</span>
  218. <span id="line214">214. }</span>
  219. <span id="line215">215. /* generic items don't have an actual-name; we shouldn't ever be called</span>
  220. <span id="line216">216. for those; pacify static analyzer without resorting to impossible() */</span>
  221. <span id="line217">217. if (!actualn)</span>
  222. <span id="line218">218. actualn = (otyp > 0 && otyp < MAXOCLASSES) ? "generic" : "object?";</span>
  223. <span id="line219">219. </span>
  224. <span id="line220">220. buf[0] = '\0'; /* redundant */</span>
  225. <span id="line221">221. switch (ocl->oc_class) {</span>
  226. <span id="line222">222. case COIN_CLASS:</span>
  227. <span id="line223">223. return strcpy(buf, actualn); /* "gold piece" */</span>
  228. <span id="line224">224. case POTION_CLASS:</span>
  229. <span id="line225">225. Strcpy(buf, "potion");</span>
  230. <span id="line226">226. break;</span>
  231. <span id="line227">227. case SCROLL_CLASS:</span>
  232. <span id="line228">228. Strcpy(buf, "scroll");</span>
  233. <span id="line229">229. break;</span>
  234. <span id="line230">230. case WAND_CLASS:</span>
  235. <span id="line231">231. Strcpy(buf, "wand");</span>
  236. <span id="line232">232. break;</span>
  237. <span id="line233">233. case SPBOOK_CLASS:</span>
  238. <span id="line234">234. if (otyp != SPE_NOVEL) {</span>
  239. <span id="line235">235. Strcpy(buf, "spellbook");</span>
  240. <span id="line236">236. } else {</span>
  241. <span id="line237">237. Strcpy(buf, !nn ? "book" : "novel");</span>
  242. <span id="line238">238. nn = 0;</span>
  243. <span id="line239">239. }</span>
  244. <span id="line240">240. break;</span>
  245. <span id="line241">241. case RING_CLASS:</span>
  246. <span id="line242">242. Strcpy(buf, "ring");</span>
  247. <span id="line243">243. break;</span>
  248. <span id="line244">244. case AMULET_CLASS:</span>
  249. <span id="line245">245. if (nn)</span>
  250. <span id="line246">246. Strcpy(buf, actualn);</span>
  251. <span id="line247">247. else</span>
  252. <span id="line248">248. Strcpy(buf, "amulet");</span>
  253. <span id="line249">249. if (un)</span>
  254. <span id="line250">250. xcalled(buf, BUFSZ - (dn ? (int) strlen(dn) + 3 : 0), "", un);</span>
  255. <span id="line251">251. if (dn)</span>
  256. <span id="line252">252. Sprintf(eos(buf), " (%s)", dn);</span>
  257. <span id="line253">253. return buf;</span>
  258. <span id="line254">254. case ARMOR_CLASS:</span>
  259. <span id="line255">255. if (objects[otyp].oc_armcat == ARM_GLOVES</span>
  260. <span id="line256">256. || objects[otyp].oc_armcat == ARM_BOOTS)</span>
  261. <span id="line257">257. Strcpy(buf, "pair of ");</span>
  262. <span id="line258">258. else if (otyp >= GRAY_DRAGON_SCALES && otyp <= YELLOW_DRAGON_SCALES)</span>
  263. <span id="line259">259. Strcpy(buf, "set of ");</span>
  264. <span id="line260">260. FALLTHROUGH;</span>
  265. <span id="line261">261. /*FALLTHRU*/</span>
  266. <span id="line262">262. default:</span>
  267. <span id="line263">263. if (nn) {</span>
  268. <span id="line264">264. Strcat(buf, actualn);</span>
  269. <span id="line265">265. if (GemStone(otyp))</span>
  270. <span id="line266">266. Strcat(buf, " stone");</span>
  271. <span id="line267">267. if (un) /* 3: length of " (" + ")" which will enclose 'dn' */</span>
  272. <span id="line268">268. xcalled(buf, BUFSZ - (dn ? (int) strlen(dn) + 3 : 0), "", un);</span>
  273. <span id="line269">269. if (dn)</span>
  274. <span id="line270">270. Sprintf(eos(buf), " (%s)", dn);</span>
  275. <span id="line271">271. } else {</span>
  276. <span id="line272">272. Strcat(buf, dn ? dn : actualn);</span>
  277. <span id="line273">273. if (ocl->oc_class == GEM_CLASS)</span>
  278. <span id="line274">274. Strcat(buf,</span>
  279. <span id="line275">275. (ocl->oc_material == MINERAL) ? " stone" : " gem");</span>
  280. <span id="line276">276. if (un)</span>
  281. <span id="line277">277. xcalled(buf, BUFSZ, "", un);</span>
  282. <span id="line278">278. }</span>
  283. <span id="line279">279. return buf;</span>
  284. <span id="line280">280. }</span>
  285. <span id="line281">281. /* here for ring/scroll/potion/wand */</span>
  286. <span id="line282">282. if (nn) {</span>
  287. <span id="line283">283. if (ocl->oc_unique)</span>
  288. <span id="line284">284. Strcpy(buf, actualn); /* avoid spellbook of Book of the Dead */</span>
  289. <span id="line285">285. else</span>
  290. <span id="line286">286. Sprintf(eos(buf), " of %s", actualn);</span>
  291. <span id="line287">287. }</span>
  292. <span id="line288">288. if (un) /* 3: length of " (" + ")" which will enclose 'dn' */</span>
  293. <span id="line289">289. xcalled(buf, BUFSZ - (dn ? (int) strlen(dn) + 3 : 0), "", un);</span>
  294. <span id="line290">290. if (dn)</span>
  295. <span id="line291">291. Sprintf(eos(buf), " (%s)", dn);</span>
  296. <span id="line292">292. return buf;</span>
  297. <span id="line293">293. }</span>
  298. <span id="line294">294. </span>
  299. <span id="line295">295. /* less verbose result than obj_typename(); either the actual name</span>
  300. <span id="line296">296. or the description (but not both); user-assigned name is ignored */</span>
  301. <span id="line297">297. char *</span>
  302. <span id="line298">298. simple_typename(int otyp)</span>
  303. <span id="line299">299. {</span>
  304. <span id="line300">300. char *bufp, *pp, *save_uname = objects[otyp].oc_uname;</span>
  305. <span id="line301">301. </span>
  306. <span id="line302">302. objects[otyp].oc_uname = 0; /* suppress any name given by user */</span>
  307. <span id="line303">303. bufp = obj_typename(otyp);</span>
  308. <span id="line304">304. objects[otyp].oc_uname = save_uname;</span>
  309. <span id="line305">305. if ((pp = strstri(bufp, " (")) != 0)</span>
  310. <span id="line306">306. *pp = '\0'; /* strip the appended description */</span>
  311. <span id="line307">307. return bufp;</span>
  312. <span id="line308">308. }</span>
  313. <span id="line309">309. </span>
  314. <span id="line310">310. /* typename for debugging feedback where data involved might be suspect */</span>
  315. <span id="line311">311. char *</span>
  316. <span id="line312">312. safe_typename(int otyp)</span>
  317. <span id="line313">313. {</span>
  318. <span id="line314">314. unsigned save_nameknown;</span>
  319. <span id="line315">315. char *res = 0;</span>
  320. <span id="line316">316. </span>
  321. <span id="line317">317. if (otyp < STRANGE_OBJECT || otyp >= NUM_OBJECTS</span>
  322. <span id="line318">318. || !OBJ_NAME(objects[otyp])) {</span>
  323. <span id="line319">319. res = nextobuf();</span>
  324. <span id="line320">320. Sprintf(res, "glorkum[%d]", otyp);</span>
  325. <span id="line321">321. impossible("safe_typename: %s", res);</span>
  326. <span id="line322">322. } else {</span>
  327. <span id="line323">323. /* force it to be treated as fully discovered */</span>
  328. <span id="line324">324. save_nameknown = objects[otyp].oc_name_known;</span>
  329. <span id="line325">325. objects[otyp].oc_name_known = 1;</span>
  330. <span id="line326">326. res = simple_typename(otyp);</span>
  331. <span id="line327">327. objects[otyp].oc_name_known = save_nameknown;</span>
  332. <span id="line328">328. }</span>
  333. <span id="line329">329. return res;</span>
  334. <span id="line330">330. }</span>
  335. <span id="line331">331. </span>
  336. <span id="line332">332. boolean</span>
  337. <span id="line333">333. obj_is_pname(struct obj *obj)</span>
  338. <span id="line334">334. {</span>
  339. <span id="line335">335. if (!obj->oartifact || !has_oname(obj))</span>
  340. <span id="line336">336. return FALSE;</span>
  341. <span id="line337">337. if (!program_state.gameover && !iflags.override_ID) {</span>
  342. <span id="line338">338. if (not_fully_identified(obj))</span>
  343. <span id="line339">339. return FALSE;</span>
  344. <span id="line340">340. }</span>
  345. <span id="line341">341. return TRUE;</span>
  346. <span id="line342">342. }</span>
  347. <span id="line343">343. </span>
  348. <span id="line344">344. /* Give the name of an object seen at a distance. Unlike xname/doname,</span>
  349. <span id="line345">345. we usually don't want to set dknown if it's not set already. */</span>
  350. <span id="line346">346. char *</span>
  351. <span id="line347">347. distant_name(</span>
  352. <span id="line348">348. struct obj *obj, /* object to be formatted */</span>
  353. <span id="line349">349. char *(*func)(OBJ_P)) /* formatting routine (usually xname or doname) */</span>
  354. <span id="line350">350. {</span>
  355. <span id="line351">351. char *str;</span>
  356. <span id="line352">352. unsigned save_oid;</span>
  357. <span id="line353">353. coordxy ox = 0, oy = 0;</span>
  358. <span id="line354">354. /*</span>
  359. <span id="line355">355. * (r * r): square of the x or y distance;</span>
  360. <span id="line356">356. * (r * r) * 2: sum of squares of both x and y distances</span>
  361. <span id="line357">357. * (r * r) * 2 - r: instead of a square extending from the hero,</span>
  362. <span id="line358">358. * round the corners (so shorter distance imposed for diagonal).</span>
  363. <span id="line359">359. *</span>
  364. <span id="line360">360. * distu() matrix covering a range of 3+ for one quadrant:</span>
  365. <span id="line361">361. * 16 17 - - -</span>
  366. <span id="line362">362. * 9 10 13 18 -</span>
  367. <span id="line363">363. * 4 5 8 13 -</span>
  368. <span id="line364">364. * 1 2 5 10 17</span>
  369. <span id="line365">365. * @ 1 4 9 16</span>
  370. <span id="line366">366. * Theoretical r==1 would yield 1.</span>
  371. <span id="line367">367. * r==2 yields 6, functionally equivalent to 5, a knight's jump,</span>
  372. <span id="line368">368. * r==3, the xray range of the Eyes of the Overworld, yields 15.</span>
  373. <span id="line369">369. */</span>
  374. <span id="line370">370. int r = (u.xray_range > 2) ? u.xray_range : 2,</span>
  375. <span id="line371">371. neardist = (r * r) * 2 - r; /* same as r*r + r*(r-1) */</span>
  376. <span id="line372">372. </span>
  377. <span id="line373">373. /* setting o_id to 0 prevents xname() from adding T-shirt or apron</span>
  378. <span id="line374">374. slogan, Hawaiian shirt motif, or candy wrapper label when called</span>
  379. <span id="line375">375. with 'program_state.gameover' set; we want this suppression for</span>
  380. <span id="line376">376. html-dump (not implemented in nethack) to prevent object-on-map</span>
  381. <span id="line377">377. tooltips from including that extra text; also guards against a</span>
  382. <span id="line378">378. potential change to minimal_xname() [indirectly used by attribute</span>
  383. <span id="line379">379. disclosure] that propagates o_id rather than leave it 0, and</span>
  384. <span id="line380">380. against a potential extra chance to browse the map with getpos()</span>
  385. <span id="line381">381. during final disclosure (not currently implemented, nor planned) */</span>
  386. <span id="line382">382. save_oid = obj->o_id;</span>
  387. <span id="line383">383. if (program_state.gameover)</span>
  388. <span id="line384">384. obj->o_id = 0;</span>
  389. <span id="line385">385. </span>
  390. <span id="line386">386. /* this maybe-nearby part used to be replicated in multiple callers */</span>
  391. <span id="line387">387. if (get_obj_location(obj, &ox, &oy, 0) && cansee(ox, oy)</span>
  392. <span id="line388">388. && (obj->oartifact || distu(ox, oy) <= neardist)) {</span>
  393. <span id="line389">389. /* side-effects: treat as having been seen up close;</span>
  394. <span id="line390">390. cansee() is True hence hero isn't Blind so if 'func' is</span>
  395. <span id="line391">391. the usual doname or xname, obj->dknown will become set</span>
  396. <span id="line392">392. and then for an artifact, find_artifact() will be called */</span>
  397. <span id="line393">393. str = (*func)(obj);</span>
  398. <span id="line394">394. } else {</span>
  399. <span id="line395">395. /* prior to 3.6.1, this used to save current blindness state,</span>
  400. <span id="line396">396. explicitly set state to hero-is-blind, make the call (which</span>
  401. <span id="line397">397. won't set obj->dknown when blind), then restore the saved</span>
  402. <span id="line398">398. value; but the Eyes of the Overworld override blindness and</span>
  403. <span id="line399">399. would let characters wearing them get obj->dknown set for</span>
  404. <span id="line400">400. distant items, so the external flag was added */</span>
  405. <span id="line401">401. ++gd.distantname;</span>
  406. <span id="line402">402. str = (*func)(obj);</span>
  407. <span id="line403">403. --gd.distantname;</span>
  408. <span id="line404">404. }</span>
  409. <span id="line405">405. </span>
  410. <span id="line406">406. obj->o_id = save_oid; /* reset to normal */</span>
  411. <span id="line407">407. </span>
  412. <span id="line408">408. return str;</span>
  413. <span id="line409">409. }</span>
  414. <span id="line410">410. </span>
  415. <span id="line411">411. /* convert player specified fruit name into corresponding fruit juice name</span>
  416. <span id="line412">412. ("slice of pizza" -> "pizza juice" rather than "slice of pizza juice") */</span>
  417. <span id="line413">413. char *</span>
  418. <span id="line414">414. fruitname(</span>
  419. <span id="line415">415. boolean juice) /* whether or not to append " juice" to the name */</span>
  420. <span id="line416">416. {</span>
  421. <span id="line417">417. char *buf = nextobuf();</span>
  422. <span id="line418">418. const char *fruit_nam = strstri(svp.pl_fruit, " of ");</span>
  423. <span id="line419">419. </span>
  424. <span id="line420">420. if (fruit_nam)</span>
  425. <span id="line421">421. fruit_nam += 4; /* skip past " of " */</span>
  426. <span id="line422">422. else</span>
  427. <span id="line423">423. fruit_nam = svp.pl_fruit; /* use it as is */</span>
  428. <span id="line424">424. </span>
  429. <span id="line425">425. Sprintf(buf, "%s%s", makesingular(fruit_nam), juice ? " juice" : "");</span>
  430. <span id="line426">426. return buf;</span>
  431. <span id="line427">427. }</span>
  432. <span id="line428">428. </span>
  433. <span id="line429">429. /* look up a named fruit by index (1..127) */</span>
  434. <span id="line430">430. struct fruit *</span>
  435. <span id="line431">431. fruit_from_indx(int indx)</span>
  436. <span id="line432">432. {</span>
  437. <span id="line433">433. struct fruit *f;</span>
  438. <span id="line434">434. </span>
  439. <span id="line435">435. for (f = gf.ffruit; f; f = f->nextf)</span>
  440. <span id="line436">436. if (f->fid == indx)</span>
  441. <span id="line437">437. break;</span>
  442. <span id="line438">438. return f;</span>
  443. <span id="line439">439. }</span>
  444. <span id="line440">440. </span>
  445. <span id="line441">441. /* look up a named fruit by name */</span>
  446. <span id="line442">442. struct fruit *</span>
  447. <span id="line443">443. fruit_from_name(</span>
  448. <span id="line444">444. const char *fname,</span>
  449. <span id="line445">445. boolean exact, /* False: prefix or exact match, True: exact match only */</span>
  450. <span id="line446">446. int *highest_fid) /* optional output; only valid if 'fname' isn't found */</span>
  451. <span id="line447">447. {</span>
  452. <span id="line448">448. struct fruit *f, *tentativef;</span>
  453. <span id="line449">449. char *altfname;</span>
  454. <span id="line450">450. unsigned k;</span>
  455. <span id="line451">451. /*</span>
  456. <span id="line452">452. * note: named fruits are case-sensitive...</span>
  457. <span id="line453">453. */</span>
  458. <span id="line454">454. </span>
  459. <span id="line455">455. if (highest_fid)</span>
  460. <span id="line456">456. *highest_fid = 0;</span>
  461. <span id="line457">457. /* first try for an exact match */</span>
  462. <span id="line458">458. for (f = gf.ffruit; f; f = f->nextf)</span>
  463. <span id="line459">459. if (!strcmp(f->fname, fname))</span>
  464. <span id="line460">460. return f;</span>
  465. <span id="line461">461. else if (highest_fid && f->fid > *highest_fid)</span>
  466. <span id="line462">462. *highest_fid = f->fid;</span>
  467. <span id="line463">463. </span>
  468. <span id="line464">464. /* didn't match as-is; if caller is willing to accept a prefix</span>
  469. <span id="line465">465. match, try to find one; we want to find the longest prefix that</span>
  470. <span id="line466">466. matches, not the first */</span>
  471. <span id="line467">467. if (!exact) {</span>
  472. <span id="line468">468. tentativef = 0;</span>
  473. <span id="line469">469. for (f = gf.ffruit; f; f = f->nextf) {</span>
  474. <span id="line470">470. k = Strlen(f->fname);</span>
  475. <span id="line471">471. if (!strncmp(f->fname, fname, k)</span>
  476. <span id="line472">472. && (!fname[k] || fname[k] == ' ')</span>
  477. <span id="line473">473. && (!tentativef || k > strlen(tentativef->fname)))</span>
  478. <span id="line474">474. tentativef = f;</span>
  479. <span id="line475">475. }</span>
  480. <span id="line476">476. f = tentativef;</span>
  481. <span id="line477">477. }</span>
  482. <span id="line478">478. /* if we still don't have a match, try singularizing the target;</span>
  483. <span id="line479">479. for exact match, that's trivial, but for prefix, it's hard */</span>
  484. <span id="line480">480. if (!f) {</span>
  485. <span id="line481">481. altfname = makesingular(fname);</span>
  486. <span id="line482">482. for (f = gf.ffruit; f; f = f->nextf) {</span>
  487. <span id="line483">483. if (!strcmp(f->fname, altfname))</span>
  488. <span id="line484">484. break;</span>
  489. <span id="line485">485. }</span>
  490. <span id="line486">486. releaseobuf(altfname);</span>
  491. <span id="line487">487. }</span>
  492. <span id="line488">488. if (!f && !exact) {</span>
  493. <span id="line489">489. char fnamebuf[BUFSZ], *p;</span>
  494. <span id="line490">490. unsigned fname_k = Strlen(fname); /* length of assumed plural fname */</span>
  495. <span id="line491">491. </span>
  496. <span id="line492">492. tentativef = 0;</span>
  497. <span id="line493">493. for (f = gf.ffruit; f; f = f->nextf) {</span>
  498. <span id="line494">494. k = Strlen(f->fname);</span>
  499. <span id="line495">495. /* reload fnamebuf[] each iteration in case it gets modified;</span>
  500. <span id="line496">496. there's no need to recalculate fname_k */</span>
  501. <span id="line497">497. Strcpy(fnamebuf, fname);</span>
  502. <span id="line498">498. /* bug? if singular of fname is longer than plural,</span>
  503. <span id="line499">499. failing the 'fname_k > k' test could skip a viable</span>
  504. <span id="line500">500. candidate; unfortunately, we can't singularize until</span>
  505. <span id="line501">501. after stripping off trailing stuff and we can't get</span>
  506. <span id="line502">502. accurate fname_k until fname has been singularized;</span>
  507. <span id="line503">503. compromise and use 'fname_k >= k' instead of '>',</span>
  508. <span id="line504">504. accepting 1 char length discrepancy without risking</span>
  509. <span id="line505">505. false match (I hope...) */</span>
  510. <span id="line506">506. if (fname_k >= k && (p = strchr(&fnamebuf[k], ' ')) != 0) {</span>
  511. <span id="line507">507. *p = '\0'; /* truncate at 1st space past length of f->fname */</span>
  512. <span id="line508">508. altfname = makesingular(fnamebuf);</span>
  513. <span id="line509">509. k = Strlen(altfname); /* actually revised 'fname_k' */</span>
  514. <span id="line510">510. if (!strcmp(f->fname, altfname)</span>
  515. <span id="line511">511. && (!tentativef || k > strlen(tentativef->fname)))</span>
  516. <span id="line512">512. tentativef = f;</span>
  517. <span id="line513">513. releaseobuf(altfname); /* avoid churning through all obufs */</span>
  518. <span id="line514">514. }</span>
  519. <span id="line515">515. }</span>
  520. <span id="line516">516. f = tentativef;</span>
  521. <span id="line517">517. }</span>
  522. <span id="line518">518. return f;</span>
  523. <span id="line519">519. }</span>
  524. <span id="line520">520. </span>
  525. <span id="line521">521. /* sort the named-fruit linked list by fruit index number */</span>
  526. <span id="line522">522. void</span>
  527. <span id="line523">523. reorder_fruit(boolean forward)</span>
  528. <span id="line524">524. {</span>
  529. <span id="line525">525. struct fruit *f, *allfr[1 + 127];</span>
  530. <span id="line526">526. int i, j, k = SIZE(allfr);</span>
  531. <span id="line527">527. </span>
  532. <span id="line528">528. for (i = 0; i < k; ++i)</span>
  533. <span id="line529">529. allfr[i] = (struct fruit *) 0;</span>
  534. <span id="line530">530. for (f = gf.ffruit; f; f = f->nextf) {</span>
  535. <span id="line531">531. /* without sanity checking, this would reduce to 'allfr[f->fid]=f' */</span>
  536. <span id="line532">532. j = f->fid;</span>
  537. <span id="line533">533. if (j < 1 || j >= k) {</span>
  538. <span id="line534">534. impossible("reorder_fruit: fruit index (%d) out of range", j);</span>
  539. <span id="line535">535. return; /* don't sort after all; should never happen... */</span>
  540. <span id="line536">536. } else if (allfr[j]) {</span>
  541. <span id="line537">537. impossible("reorder_fruit: duplicate fruit index (%d)", j);</span>
  542. <span id="line538">538. return;</span>
  543. <span id="line539">539. }</span>
  544. <span id="line540">540. allfr[j] = f;</span>
  545. <span id="line541">541. }</span>
  546. <span id="line542">542. gf.ffruit = 0; /* reset linked list; we're rebuilding it from scratch */</span>
  547. <span id="line543">543. /* slot [0] will always be empty; must start 'i' at 1 to avoid</span>
  548. <span id="line544">544. [k - i] being out of bounds during first iteration */</span>
  549. <span id="line545">545. for (i = 1; i < k; ++i) {</span>
  550. <span id="line546">546. /* for forward ordering, go through indices from high to low;</span>
  551. <span id="line547">547. for backward ordering, go from low to high */</span>
  552. <span id="line548">548. j = forward ? (k - i) : i;</span>
  553. <span id="line549">549. if (allfr[j]) {</span>
  554. <span id="line550">550. allfr[j]->nextf = gf.ffruit;</span>
  555. <span id="line551">551. gf.ffruit = allfr[j];</span>
  556. <span id="line552">552. }</span>
  557. <span id="line553">553. }</span>
  558. <span id="line554">554. }</span>
  559. <span id="line555">555. </span>
  560. <span id="line556">556. /* add "<pfx> called <sfx>" to end of buf, truncating if necessary */</span>
  561. <span id="line557">557. staticfn void</span>
  562. <span id="line558">558. xcalled(</span>
  563. <span id="line559">559. char *buf, /* eos(obuf) or eos(&obuf[PREFIX]) */</span>
  564. <span id="line560">560. int siz, /* BUFSZ or BUFSZ-PREFIX */</span>
  565. <span id="line561">561. const char *pfx, /* usually class string, sometimes more specific */</span>
  566. <span id="line562">562. const char *sfx) /* user assigned type name */</span>
  567. <span id="line563">563. {</span>
  568. <span id="line564">564. int bufsiz = siz - 1 - (int) strlen(buf),</span>
  569. <span id="line565">565. pfxlen = (int) (strlen(pfx) + sizeof " called " - sizeof "");</span>
  570. <span id="line566">566. </span>
  571. <span id="line567">567. if (pfxlen > bufsiz)</span>
  572. <span id="line568">568. panic("xcalled: not enough room for prefix (%d > %d)",</span>
  573. <span id="line569">569. pfxlen, bufsiz);</span>
  574. <span id="line570">570. </span>
  575. <span id="line571">571. Sprintf(eos(buf), "%s called %.*s", pfx, bufsiz - pfxlen, sfx);</span>
  576. <span id="line572">572. }</span>
  577. <span id="line573">573. </span>
  578. <span id="line574">574. char *</span>
  579. <span id="line575">575. xname(struct obj *obj)</span>
  580. <span id="line576">576. {</span>
  581. <span id="line577">577. return xname_flags(obj, CXN_NORMAL);</span>
  582. <span id="line578">578. }</span>
  583. <span id="line579">579. </span>
  584. <span id="line580">580. staticfn char *</span>
  585. <span id="line581">581. xname_flags(</span>
  586. <span id="line582">582. struct obj *obj,</span>
  587. <span id="line583">583. unsigned cxn_flags) /* bitmask of CXN_xxx values */</span>
  588. <span id="line584">584. {</span>
  589. <span id="line585">585. char *buf;</span>
  590. <span id="line586">586. char *obufp, *buf_end, *buf_eos;</span>
  591. <span id="line587">587. size_t bufspaceleft;</span>
  592. <span id="line588">588. int typ = obj->otyp;</span>
  593. <span id="line589">589. struct objclass *ocl = &objects[typ];</span>
  594. <span id="line590">590. int nn = ocl->oc_name_known, omndx = obj->corpsenm;</span>
  595. <span id="line591">591. const char *actualn = OBJ_NAME(*ocl);</span>
  596. <span id="line592">592. const char *dn = OBJ_DESCR(*ocl);</span>
  597. <span id="line593">593. const char *un = ocl->oc_uname;</span>
  598. <span id="line594">594. boolean pluralize = (obj->quan != 1L) && !(cxn_flags & CXN_SINGULAR);</span>
  599. <span id="line595">595. boolean known, dknown, bknown;</span>
  600. <span id="line596">596. </span>
  601. <span id="line597">597. gx.xnamep = nextobuf();</span>
  602. <span id="line598">598. /* set up primary work buffer; the first 'PREFIX' bytes are set</span>
  603. <span id="line599">599. aside for use by doname() */</span>
  604. <span id="line600">600. buf = gx.xnamep + PREFIX; /* leave room for "17 -3 " */</span>
  605. <span id="line601">601. buf_end = gx.xnamep + BUFSZ - 1; /* last byte within the obuf[] */</span>
  606. <span id="line602">602. buf[0] = '\0';</span>
  607. <span id="line603">603. ConcUpdate(buf); /* set buf_eos and bufspaceleft */</span>
  608. <span id="line604">604. </span>
  609. <span id="line605">605. if (Role_if(PM_SAMURAI)) {</span>
  610. <span id="line606">606. actualn = Japanese_item_name(typ, actualn);</span>
  611. <span id="line607">607. if (typ == WOODEN_HARP || typ == MAGIC_HARP)</span>
  612. <span id="line608">608. dn = "koto";</span>
  613. <span id="line609">609. }</span>
  614. <span id="line610">610. /* generic items don't have an actual-name; we shouldn't ever be called</span>
  615. <span id="line611">611. for those; pacify static analyzer without resorting to impossible() */</span>
  616. <span id="line612">612. if (!actualn)</span>
  617. <span id="line613">613. actualn = (typ > 0 && typ < MAXOCLASSES) ? "generic" : "object?";</span>
  618. <span id="line614">614. /* 3.6.2: this used to be part of 'dn's initialization, but it</span>
  619. <span id="line615">615. needs to come after possibly overriding 'actualn' */</span>
  620. <span id="line616">616. if (!dn)</span>
  621. <span id="line617">617. dn = actualn;</span>
  622. <span id="line618">618. </span>
  623. <span id="line619">619. /*</span>
  624. <span id="line620">620. * clean up known when it's tied to oc_name_known, eg after AD_DRIN</span>
  625. <span id="line621">621. * This is only required for unique objects since the article</span>
  626. <span id="line622">622. * printed for the object is tied to the combination of the two</span>
  627. <span id="line623">623. * and printing the wrong article gives away information.</span>
  628. <span id="line624">624. */</span>
  629. <span id="line625">625. if (!nn && ocl->oc_uses_known && ocl->oc_unique)</span>
  630. <span id="line626">626. obj->known = 0;</span>
  631. <span id="line627">627. if (!Blind && !gd.distantname)</span>
  632. <span id="line628">628. observe_object(obj);</span>
  633. <span id="line629">629. if (Role_if(PM_CLERIC))</span>
  634. <span id="line630">630. obj->bknown = 1; /* avoid set_bknown() to bypass update_inventory() */</span>
  635. <span id="line631">631. </span>
  636. <span id="line632">632. if (iflags.override_ID) {</span>
  637. <span id="line633">633. known = dknown = bknown = TRUE;</span>
  638. <span id="line634">634. nn = 1;</span>
  639. <span id="line635">635. } else {</span>
  640. <span id="line636">636. known = obj->known;</span>
  641. <span id="line637">637. dknown = obj->dknown;</span>
  642. <span id="line638">638. bknown = obj->bknown;</span>
  643. <span id="line639">639. }</span>
  644. <span id="line640">640. </span>
  645. <span id="line641">641. /*</span>
  646. <span id="line642">642. * Maybe find a previously unseen artifact.</span>
  647. <span id="line643">643. *</span>
  648. <span id="line644">644. * Assumption 1: if an artifact object is being formatted, it is</span>
  649. <span id="line645">645. * being shown to the hero (on floor, or looking into container,</span>
  650. <span id="line646">646. * or probing a monster, or seeing a monster wield it).</span>
  651. <span id="line647">647. * Assumption 2: if in a pile that has been stepped on, the</span>
  652. <span id="line648">648. * artifact won't be noticed for cases where the pile to too deep</span>
  653. <span id="line649">649. * to be auto-shown, unless the player explicitly looks at that</span>
  654. <span id="line650">650. * spot (via ':'). Might need to make an exception somehow (at</span>
  655. <span id="line651">651. * the point where the decision whether to auto-show gets made?)</span>
  656. <span id="line652">652. * when an artifact is on the top of the pile.</span>
  657. <span id="line653">653. * Assumption 3: since this is used for livelog events, not being</span>
  658. <span id="line654">654. * 100% correct won't negatively affect the player's current game.</span>
  659. <span id="line655">655. *</span>
  660. <span id="line656">656. * We use the real obj->dknown rather than the override_ID variant</span>
  661. <span id="line657">657. * so that wizard-mode ^I doesn't cause a not-yet-seen artifact in</span>
  662. <span id="line658">658. * inventory (picked up while blind, still blind) to become found.</span>
  663. <span id="line659">659. */</span>
  664. <span id="line660">660. if (obj->oartifact && obj->dknown)</span>
  665. <span id="line661">661. find_artifact(obj);</span>
  666. <span id="line662">662. </span>
  667. <span id="line663">663. if (obj_is_pname(obj))</span>
  668. <span id="line664">664. goto nameit;</span>
  669. <span id="line665">665. </span>
  670. <span id="line666">666. /* Some classes use strcpy(buf, something)+strcat(buf, otherthing).</span>
  671. <span id="line667">667. In those cases, ConcUpdate() is needed in between if Concat()</span>
  672. <span id="line668">668. will be used for the strcat() part. Other classes just use</span>
  673. <span id="line669">669. strcpy(buf, something) and the ConcUpdate() can be deferred</span>
  674. <span id="line670">670. until after the switch. */</span>
  675. <span id="line671">671. switch (obj->oclass) {</span>
  676. <span id="line672">672. case AMULET_CLASS:</span>
  677. <span id="line673">673. if (!dknown)</span>
  678. <span id="line674">674. Strcpy(buf, "amulet");</span>
  679. <span id="line675">675. else if (typ == AMULET_OF_YENDOR || typ == FAKE_AMULET_OF_YENDOR)</span>
  680. <span id="line676">676. /* each must be identified individually */</span>
  681. <span id="line677">677. Strcpy(buf, known ? actualn : dn);</span>
  682. <span id="line678">678. else if (nn)</span>
  683. <span id="line679">679. Strcpy(buf, actualn);</span>
  684. <span id="line680">680. else if (un)</span>
  685. <span id="line681">681. xcalled(buf, BUFSZ - PREFIX, "amulet", un);</span>
  686. <span id="line682">682. else</span>
  687. <span id="line683">683. Sprintf(buf, "%s amulet", dn);</span>
  688. <span id="line684">684. break;</span>
  689. <span id="line685">685. case WEAPON_CLASS:</span>
  690. <span id="line686">686. if (is_poisonable(obj) && obj->opoisoned)</span>
  691. <span id="line687">687. Strcpy(buf, "poisoned ");</span>
  692. <span id="line688">688. FALLTHROUGH;</span>
  693. <span id="line689">689. /*FALLTHRU*/</span>
  694. <span id="line690">690. case VENOM_CLASS:</span>
  695. <span id="line691">691. case TOOL_CLASS:</span>
  696. <span id="line692">692. /* note: lenses or towel prefix would overwrite poisoned weapon</span>
  697. <span id="line693">693. prefix if both were simultaneously possible, but they aren't */</span>
  698. <span id="line694">694. if (typ == LENSES)</span>
  699. <span id="line695">695. Strcpy(buf, "pair of ");</span>
  700. <span id="line696">696. else if (is_wet_towel(obj))</span>
  701. <span id="line697">697. Strcpy(buf, (obj->spe < 3) ? "moist " : "wet ");</span>
  702. <span id="line698">698. </span>
  703. <span id="line699">699. if (!dknown)</span>
  704. <span id="line700">700. Strcat(buf, dn);</span>
  705. <span id="line701">701. else if (nn)</span>
  706. <span id="line702">702. Strcat(buf, actualn);</span>
  707. <span id="line703">703. else if (un)</span>
  708. <span id="line704">704. xcalled(buf, BUFSZ - PREFIX, dn, un);</span>
  709. <span id="line705">705. else</span>
  710. <span id="line706">706. Strcat(buf, dn);</span>
  711. <span id="line707">707. ConcUpdate(buf);</span>
  712. <span id="line708">708. </span>
  713. <span id="line709">709. if (typ == FIGURINE && omndx != NON_PM) {</span>
  714. <span id="line710">710. char anbuf[10]; /* [4] would be enough: 'a','n',' ','\0' */</span>
  715. <span id="line711">711. const char *pm_name = obj_pmname(obj);</span>
  716. <span id="line712">712. </span>
  717. <span id="line713">713. ConcatF2(buf, 0, " of %s%s", just_an(anbuf, pm_name), pm_name);</span>
  718. <span id="line714">714. } else if (is_wet_towel(obj)) {</span>
  719. <span id="line715">715. if (wizard)</span>
  720. <span id="line716">716. ConcatF1(buf, 0, " (%d)", obj->spe);</span>
  721. <span id="line717">717. }</span>
  722. <span id="line718">718. break;</span>
  723. <span id="line719">719. case ARMOR_CLASS:</span>
  724. <span id="line720">720. /* depends on order of the dragon scales objects */</span>
  725. <span id="line721">721. if (typ >= GRAY_DRAGON_SCALES && typ <= YELLOW_DRAGON_SCALES) {</span>
  726. <span id="line722">722. Sprintf(buf, "set of %s", actualn);</span>
  727. <span id="line723">723. break;</span>
  728. <span id="line724">724. } else if (is_boots(obj) || is_gloves(obj)) {</span>
  729. <span id="line725">725. Strcpy(buf, "pair of ");</span>
  730. <span id="line726">726. /*FALLTHRU*/</span>
  731. <span id="line727">727. } else if (is_shield(obj) && !dknown) {</span>
  732. <span id="line728">728. if (obj->otyp >= ELVEN_SHIELD && obj->otyp <= ORCISH_SHIELD) {</span>
  733. <span id="line729">729. Strcpy(buf, "shield");</span>
  734. <span id="line730">730. break;</span>
  735. <span id="line731">731. } else if (obj->otyp == SHIELD_OF_REFLECTION) {</span>
  736. <span id="line732">732. Strcpy(buf, "smooth shield");</span>
  737. <span id="line733">733. break;</span>
  738. <span id="line734">734. }</span>
  739. <span id="line735">735. }</span>
  740. <span id="line736">736. ConcUpdate(buf);</span>
  741. <span id="line737">737. </span>
  742. <span id="line738">738. if (nn)</span>
  743. <span id="line739">739. Concat(buf, 0, actualn);</span>
  744. <span id="line740">740. else if (un)</span>
  745. <span id="line741">741. xcalled(buf, BUFSZ - PREFIX, armor_simple_name(obj), un);</span>
  746. <span id="line742">742. else</span>
  747. <span id="line743">743. Concat(buf, 0, dn);</span>
  748. <span id="line744">744. break;</span>
  749. <span id="line745">745. case FOOD_CLASS:</span>
  750. <span id="line746">746. /* we could include partly-eaten-hack on fruit but don't need to */</span>
  751. <span id="line747">747. if (typ == SLIME_MOLD) {</span>
  752. <span id="line748">748. struct fruit *f = fruit_from_indx(obj->spe);</span>
  753. <span id="line749">749. </span>
  754. <span id="line750">750. if (!f) {</span>
  755. <span id="line751">751. impossible("Bad fruit #%d?", obj->spe);</span>
  756. <span id="line752">752. Strcpy(buf, "fruit");</span>
  757. <span id="line753">753. } else {</span>
  758. <span id="line754">754. /* fruit name is limited in length to PL_FSIZ; converting</span>
  759. <span id="line755">755. to/from singular/plural might increase the length a</span>
  760. <span id="line756">756. little but not enough to pose a risk of overflowing buf */</span>
  761. <span id="line757">757. Strcpy(buf, f->fname);</span>
  762. <span id="line758">758. if (pluralize) {</span>
  763. <span id="line759">759. /* ick: already pluralized fruit names are allowed--we</span>
  764. <span id="line760">760. want to try to avoid adding a redundant plural suffix;</span>
  765. <span id="line761">761. double ick: makesingular() and makeplural() each use</span>
  766. <span id="line762">762. and return an obuf but we don't want any particular</span>
  767. <span id="line763">763. xname() call to consume more than one of those</span>
  768. <span id="line764">764. [note: makeXXX() will be fully evaluated and done with</span>
  769. <span id="line765">765. 'buf' before strcpy() touches its output buffer] */</span>
  770. <span id="line766">766. Strcpy(buf, obufp = makesingular(buf));</span>
  771. <span id="line767">767. releaseobuf(obufp);</span>
  772. <span id="line768">768. Strcpy(buf, obufp = makeplural(buf));</span>
  773. <span id="line769">769. releaseobuf(obufp);</span>
  774. <span id="line770">770. </span>
  775. <span id="line771">771. pluralize = FALSE;</span>
  776. <span id="line772">772. }</span>
  777. <span id="line773">773. }</span>
  778. <span id="line774">774. break;</span>
  779. <span id="line775">775. }</span>
  780. <span id="line776">776. if (iflags.partly_eaten_hack && obj->oeaten) {</span>
  781. <span id="line777">777. /* normally "partly eaten" is supplied by doname() when</span>
  782. <span id="line778">778. appropriate and omitted by xname(); shrink_glob() wants</span>
  783. <span id="line779">779. it but uses Yname2() -> yname() -> xname() rather than</span>
  784. <span id="line780">780. doname() so we've added an external flag to request it */</span>
  785. <span id="line781">781. Concat(buf, 0, "partly eaten ");</span>
  786. <span id="line782">782. }</span>
  787. <span id="line783">783. if (obj->globby) { /* 5.0 added "medium" to replace no-prefix */</span>
  788. <span id="line784">784. ConcatF2(buf, 0, "%s %s", (obj->owt <= 100) ? "small"</span>
  789. <span id="line785">785. : (obj->owt <= 300) ? "medium"</span>
  790. <span id="line786">786. : (obj->owt <= 500) ? "large"</span>
  791. <span id="line787">787. : "very large",</span>
  792. <span id="line788">788. actualn);</span>
  793. <span id="line789">789. break;</span>
  794. <span id="line790">790. }</span>
  795. <span id="line791">791. </span>
  796. <span id="line792">792. Concat(buf, 0, actualn);</span>
  797. <span id="line793">793. if (typ == TIN && known)</span>
  798. <span id="line794">794. tin_details(obj, omndx, buf);</span>
  799. <span id="line795">795. break;</span>
  800. <span id="line796">796. case COIN_CLASS:</span>
  801. <span id="line797">797. case CHAIN_CLASS:</span>
  802. <span id="line798">798. Strcpy(buf, actualn);</span>
  803. <span id="line799">799. break;</span>
  804. <span id="line800">800. case ROCK_CLASS:</span>
  805. <span id="line801">801. if (typ == STATUE && omndx != NON_PM) {</span>
  806. <span id="line802">802. char anbuf[10];</span>
  807. <span id="line803">803. const char *statue_pmname = obj_pmname(obj);</span>
  808. <span id="line804">804. </span>
  809. <span id="line805">805. Snprintf(buf, bufspaceleft, "%s%s of %s%s",</span>
  810. <span id="line806">806. (Role_if(PM_ARCHEOLOGIST)</span>
  811. <span id="line807">807. && (obj->spe & CORPSTAT_HISTORIC) != 0) ? "historic "</span>
  812. <span id="line808">808. : "",</span>
  813. <span id="line809">809. actualn,</span>
  814. <span id="line810">810. type_is_pname(&mons[omndx]) ? ""</span>
  815. <span id="line811">811. : the_unique_pm(&mons[omndx]) ? "the "</span>
  816. <span id="line812">812. : just_an(anbuf, statue_pmname),</span>
  817. <span id="line813">813. statue_pmname);</span>
  818. <span id="line814">814. } else if (typ == BOULDER && obj->next_boulder == 1) {</span>
  819. <span id="line815">815. /* sometimes caller wants "next boulder" rather than just</span>
  820. <span id="line816">816. "boulder" (when pushing against a pile of more than one);</span>
  821. <span id="line817">817. originally we just tested for non-0 but checking for 1 is</span>
  822. <span id="line818">818. more robust because the default value for that overloaded</span>
  823. <span id="line819">819. field (obj->corpsenm) is NON_PM (-1) rather than 0 */</span>
  824. <span id="line820">820. Strcat(strcpy(buf, "next "), actualn); /* "next boulder" */</span>
  825. <span id="line821">821. /* once "next boulder" occurs, subsequent messages should just</span>
  826. <span id="line822">822. use ordinary "boulder" */</span>
  827. <span id="line823">823. obj->next_boulder = 0;</span>
  828. <span id="line824">824. } else {</span>
  829. <span id="line825">825. Strcpy(buf, actualn); /* "boulder" or "statue" */</span>
  830. <span id="line826">826. }</span>
  831. <span id="line827">827. break;</span>
  832. <span id="line828">828. case BALL_CLASS:</span>
  833. <span id="line829">829. Sprintf(buf, "%sheavy iron ball",</span>
  834. <span id="line830">830. (obj->owt > ocl->oc_weight) ? "very " : "");</span>
  835. <span id="line831">831. break;</span>
  836. <span id="line832">832. case POTION_CLASS:</span>
  837. <span id="line833">833. if (dknown && obj->odiluted)</span>
  838. <span id="line834">834. Strcpy(buf, "diluted ");</span>
  839. <span id="line835">835. if (nn || un || !dknown) {</span>
  840. <span id="line836">836. Strcat(buf, "potion");</span>
  841. <span id="line837">837. if (!dknown)</span>
  842. <span id="line838">838. break;</span>
  843. <span id="line839">839. if (nn) {</span>
  844. <span id="line840">840. Strcat(buf, " of ");</span>
  845. <span id="line841">841. if (typ == POT_WATER && bknown</span>
  846. <span id="line842">842. && (obj->blessed || obj->cursed)) {</span>
  847. <span id="line843">843. Strcat(buf, obj->blessed ? "holy " : "unholy ");</span>
  848. <span id="line844">844. }</span>
  849. <span id="line845">845. Strcat(buf, actualn);</span>
  850. <span id="line846">846. } else {</span>
  851. <span id="line847">847. xcalled(buf, BUFSZ - PREFIX, "", un);</span>
  852. <span id="line848">848. }</span>
  853. <span id="line849">849. } else {</span>
  854. <span id="line850">850. Strcat(buf, dn);</span>
  855. <span id="line851">851. Strcat(buf, " potion");</span>
  856. <span id="line852">852. }</span>
  857. <span id="line853">853. break;</span>
  858. <span id="line854">854. case SCROLL_CLASS:</span>
  859. <span id="line855">855. Strcpy(buf, "scroll");</span>
  860. <span id="line856">856. if (!dknown)</span>
  861. <span id="line857">857. break;</span>
  862. <span id="line858">858. if (nn) {</span>
  863. <span id="line859">859. Strcat(buf, " of ");</span>
  864. <span id="line860">860. Strcat(buf, actualn);</span>
  865. <span id="line861">861. } else if (un) {</span>
  866. <span id="line862">862. xcalled(buf, BUFSZ - PREFIX, "", un);</span>
  867. <span id="line863">863. } else if (ocl->oc_magic) {</span>
  868. <span id="line864">864. Strcat(buf, " labeled ");</span>
  869. <span id="line865">865. Strcat(buf, dn);</span>
  870. <span id="line866">866. } else {</span>
  871. <span id="line867">867. Strcpy(buf, dn);</span>
  872. <span id="line868">868. Strcat(buf, " scroll");</span>
  873. <span id="line869">869. }</span>
  874. <span id="line870">870. break;</span>
  875. <span id="line871">871. case WAND_CLASS:</span>
  876. <span id="line872">872. if (!dknown)</span>
  877. <span id="line873">873. Strcpy(buf, "wand");</span>
  878. <span id="line874">874. else if (nn)</span>
  879. <span id="line875">875. Sprintf(buf, "wand of %s", actualn);</span>
  880. <span id="line876">876. else if (un)</span>
  881. <span id="line877">877. xcalled(buf, BUFSZ - PREFIX, "wand", un);</span>
  882. <span id="line878">878. else</span>
  883. <span id="line879">879. Sprintf(buf, "%s wand", dn);</span>
  884. <span id="line880">880. break;</span>
  885. <span id="line881">881. case SPBOOK_CLASS:</span>
  886. <span id="line882">882. if (typ == SPE_NOVEL) { /* 3.6 tribute */</span>
  887. <span id="line883">883. if (!dknown)</span>
  888. <span id="line884">884. Strcpy(buf, "book");</span>
  889. <span id="line885">885. else if (nn)</span>
  890. <span id="line886">886. Strcpy(buf, actualn);</span>
  891. <span id="line887">887. else if (un)</span>
  892. <span id="line888">888. xcalled(buf, BUFSZ - PREFIX, "novel", un);</span>
  893. <span id="line889">889. else</span>
  894. <span id="line890">890. Sprintf(buf, "%s book", dn);</span>
  895. <span id="line891">891. break;</span>
  896. <span id="line892">892. /* end of tribute */</span>
  897. <span id="line893">893. } else if (!dknown) {</span>
  898. <span id="line894">894. Strcpy(buf, "spellbook");</span>
  899. <span id="line895">895. } else if (nn) {</span>
  900. <span id="line896">896. if (typ != SPE_BOOK_OF_THE_DEAD)</span>
  901. <span id="line897">897. Strcpy(buf, "spellbook of ");</span>
  902. <span id="line898">898. Strcat(buf, actualn);</span>
  903. <span id="line899">899. } else if (un) {</span>
  904. <span id="line900">900. xcalled(buf, BUFSZ - PREFIX, "spellbook", un);</span>
  905. <span id="line901">901. } else</span>
  906. <span id="line902">902. Sprintf(buf, "%s spellbook", dn);</span>
  907. <span id="line903">903. break;</span>
  908. <span id="line904">904. case RING_CLASS:</span>
  909. <span id="line905">905. if (!dknown)</span>
  910. <span id="line906">906. Strcpy(buf, "ring");</span>
  911. <span id="line907">907. else if (nn)</span>
  912. <span id="line908">908. Sprintf(buf, "ring of %s", actualn);</span>
  913. <span id="line909">909. else if (un)</span>
  914. <span id="line910">910. xcalled(buf, BUFSZ - PREFIX, "ring", un);</span>
  915. <span id="line911">911. else</span>
  916. <span id="line912">912. Sprintf(buf, "%s ring", dn);</span>
  917. <span id="line913">913. break;</span>
  918. <span id="line914">914. case GEM_CLASS: {</span>
  919. <span id="line915">915. const char *rock = (ocl->oc_material == MINERAL) ? "stone" : "gem";</span>
  920. <span id="line916">916. </span>
  921. <span id="line917">917. if (!dknown) {</span>
  922. <span id="line918">918. Strcpy(buf, rock);</span>
  923. <span id="line919">919. } else if (!nn) {</span>
  924. <span id="line920">920. if (un)</span>
  925. <span id="line921">921. xcalled(buf, BUFSZ - PREFIX, rock, un);</span>
  926. <span id="line922">922. else</span>
  927. <span id="line923">923. Sprintf(buf, "%s %s", dn, rock);</span>
  928. <span id="line924">924. } else {</span>
  929. <span id="line925">925. Strcpy(buf, actualn);</span>
  930. <span id="line926">926. if (GemStone(typ))</span>
  931. <span id="line927">927. Strcat(buf, " stone");</span>
  932. <span id="line928">928. }</span>
  933. <span id="line929">929. break;</span>
  934. <span id="line930">930. } /* gem */</span>
  935. <span id="line931">931. default:</span>
  936. <span id="line932">932. Sprintf(buf, "glorkum %d %d %d", obj->oclass, typ, obj->spe);</span>
  937. <span id="line933">933. impossible("xname_flags: %s", buf);</span>
  938. <span id="line934">934. break;</span>
  939. <span id="line935">935. } /* switch */</span>
  940. <span id="line936">936. </span>
  941. <span id="line937">937. /* check whether we've already gone out of bounds of the obuf[], prior</span>
  942. <span id="line938">938. to pluralization and end-of-game shirt and apron text */</span>
  943. <span id="line939">939. buf_eos = eos(buf);</span>
  944. <span id="line940">940. if (buf_eos > buf_end) {</span>
  945. <span id="line941">941. /* PREFIX is bigger than 6 so there will always be room within the</span>
  946. <span id="line942">942. obuf[] in front of buf to insert "buf[]="; strncpy(,,N) doesn't</span>
  947. <span id="line943">943. add '\0' terminator unless fewer than N chars are copied, which</span>
  948. <span id="line944">944. is what we want, but gcc complains about that so use memcpy() */</span>
  949. <span id="line945">945. paniclog("xname", (char *) memcpy(buf - 6, "buf[]=", 6));</span>
  950. <span id="line946">946. panic("xname: buffer overflow before appending name.");</span>
  951. <span id="line947">947. /*NOTREACHED*/</span>
  952. <span id="line948">948. }</span>
  953. <span id="line949">949. bufspaceleft = (size_t) (buf_end - buf_eos);</span>
  954. <span id="line950">950. </span>
  955. <span id="line951">951. /* if the name should be plural, do that now, after overflow check;</span>
  956. <span id="line952">952. it could make buf[] become shorter */</span>
  957. <span id="line953">953. if (pluralize) {</span>
  958. <span id="line954">954. obufp = makeplural(buf);</span>
  959. <span id="line955">955. buf[0] = '\0'; /* replace the whole string */</span>
  960. <span id="line956">956. ConcUpdate(buf); /* reset buf_eos and bufspaceleft */</span>
  961. <span id="line957">957. Concat(buf, 0, obufp);</span>
  962. <span id="line958">958. releaseobuf(obufp);</span>
  963. <span id="line959">959. }</span>
  964. <span id="line960">960. </span>
  965. <span id="line961">961. /* give some extra information when game is over; for end-of-game</span>
  966. <span id="line962">962. attribute disclosure in wizard mode, ysimple_name() calls</span>
  967. <span id="line963">963. minimal_xname() which passes us a dummy object with o_id==0;</span>
  968. <span id="line964">964. tshirt_text(), apron_text(), and so forth base their result on</span>
  969. <span id="line965">965. o_id and would give inconsistent information compared to what</span>
  970. <span id="line966">966. just got shown for inventory disclosure; fortunately, we want to</span>
  971. <span id="line967">967. avoid the 'with text' part of</span>
  972. <span id="line968">968. "You were acid resistant because of your alchemy smock \</span>
  973. <span id="line969">969. with text \"Kiss the cook\"."</span>
  974. <span id="line970">970. when disclosing attributes anyway */</span>
  975. <span id="line971">971. if (program_state.gameover && obj->o_id && bufspaceleft > 0) {</span>
  976. <span id="line972">972. const char *lbl;</span>
  977. <span id="line973">973. char tmpbuf[BUFSZ];</span>
  978. <span id="line974">974. </span>
  979. <span id="line975">975. /* disclose without breaking illiterate conduct, but mainly tip off</span>
  980. <span id="line976">976. players who aren't aware that something readable is present */</span>
  981. <span id="line977">977. switch (obj->otyp) {</span>
  982. <span id="line978">978. case T_SHIRT:</span>
  983. <span id="line979">979. case ALCHEMY_SMOCK:</span>
  984. <span id="line980">980. ConcatF1(buf, 0, " with text \"%s\"",</span>
  985. <span id="line981">981. (obj->otyp == T_SHIRT) ? tshirt_text(obj, tmpbuf)</span>
  986. <span id="line982">982. : apron_text(obj, tmpbuf));</span>
  987. <span id="line983">983. break;</span>
  988. <span id="line984">984. case CANDY_BAR:</span>
  989. <span id="line985">985. lbl = candy_wrapper_text(obj);</span>
  990. <span id="line986">986. if (*lbl)</span>
  991. <span id="line987">987. ConcatF1(buf, 0, " labeled \"%s\"", lbl);</span>
  992. <span id="line988">988. break;</span>
  993. <span id="line989">989. case HAWAIIAN_SHIRT:</span>
  994. <span id="line990">990. ConcatF1(buf, 0, " with %s motif",</span>
  995. <span id="line991">991. an(hawaiian_motif(obj, tmpbuf)));</span>
  996. <span id="line992">992. break;</span>
  997. <span id="line993">993. default:</span>
  998. <span id="line994">994. break;</span>
  999. <span id="line995">995. }</span>
  1000. <span id="line996">996. }</span>
  1001. <span id="line997">997. </span>
  1002. <span id="line998">998. if (has_oname(obj) && dknown) {</span>
  1003. <span id="line999">999. Concat(buf, 0, " named ");</span>
  1004. <span id="line1000">1000. </span>
  1005. <span id="line1001">1001. /* jump directly here if obj passes the has-personal-name test */</span>
  1006. <span id="line1002">1002. nameit:</span>
  1007. <span id="line1003">1003. /*assert(has_oname(obj));*/</span>
  1008. <span id="line1004">1004. obufp = eos(buf); /* remember where the name will start */</span>
  1009. <span id="line1005">1005. Concat(buf, 0, ONAME(obj));</span>
  1010. <span id="line1006">1006. /* downcase "The" in "<quest-artifact-item> named The ..." */</span>
  1011. <span id="line1007">1007. if (obj->oartifact && !strncmp(obufp, "The ", 4))</span>
  1012. <span id="line1008">1008. *obufp = lowc(*obufp); /* change 'T' in "The " to 't' */</span>
  1013. <span id="line1009">1009. }</span>
  1014. <span id="line1010">1010. </span>
  1015. <span id="line1011">1011. if (!strncmpi(buf, "the ", 4))</span>
  1016. <span id="line1012">1012. buf += 4;</span>
  1017. <span id="line1013">1013. </span>
  1018. <span id="line1014">1014. buf_eos = eos(buf); /* pointer to '\0' terminator somewhere in obuf[] */</span>
  1019. <span id="line1015">1015. if (buf_eos >= buf_end) { /* ('>' shouldn't be possible) */</span>
  1020. <span id="line1016">1016. static int xname_full = 0;</span>
  1021. <span id="line1017">1017. </span>
  1022. <span id="line1018">1018. /* we want a record of something needing more buffer space than</span>
  1023. <span id="line1019">1019. anticipated; since we aren't panicking here, this could happen</span>
  1024. <span id="line1020">1020. repeatedly and we don't want to spam the paniclog file */</span>
  1025. <span id="line1021">1021. if (!xname_full++) {</span>
  1026. <span id="line1022">1022. paniclog("xname", (char *) memcpy(buf - 6, "buf[]=", 6));</span>
  1027. <span id="line1023">1023. /* 'PREFIX' ought to be 'PREFIX+4' if we stripped leading "the" */</span>
  1028. <span id="line1024">1024. paniclog("xname", "used up entire obuf[PREFIX..BUFSX-1]");</span>
  1029. <span id="line1025">1025. }</span>
  1030. <span id="line1026">1026. }</span>
  1031. <span id="line1027">1027. </span>
  1032. <span id="line1028">1028. return buf;</span>
  1033. <span id="line1029">1029. }</span>
  1034. <span id="line1030">1030. </span>
  1035. <span id="line1031">1031. /* similar to simple_typename but minimal_xname operates on a particular</span>
  1036. <span id="line1032">1032. object rather than its general type; it formats the most basic info:</span>
  1037. <span id="line1033">1033. potion -- if description not known</span>
  1038. <span id="line1034">1034. brown potion -- if oc_name_known not set</span>
  1039. <span id="line1035">1035. potion of object detection -- if discovered</span>
  1040. <span id="line1036">1036. */</span>
  1041. <span id="line1037">1037. staticfn char *</span>
  1042. <span id="line1038">1038. minimal_xname(struct obj *obj)</span>
  1043. <span id="line1039">1039. {</span>
  1044. <span id="line1040">1040. char *bufp;</span>
  1045. <span id="line1041">1041. struct obj bareobj;</span>
  1046. <span id="line1042">1042. struct objclass saveobcls;</span>
  1047. <span id="line1043">1043. int otyp = obj->otyp;</span>
  1048. <span id="line1044">1044. </span>
  1049. <span id="line1045">1045. /* suppress user-supplied name */</span>
  1050. <span id="line1046">1046. saveobcls.oc_uname = objects[otyp].oc_uname;</span>
  1051. <span id="line1047">1047. objects[otyp].oc_uname = 0;</span>
  1052. <span id="line1048">1048. /* suppress actual name if object's description is unknown */</span>
  1053. <span id="line1049">1049. saveobcls.oc_name_known = objects[otyp].oc_name_known;</span>
  1054. <span id="line1050">1050. if (iflags.override_ID)</span>
  1055. <span id="line1051">1051. objects[otyp].oc_name_known = 1;</span>
  1056. <span id="line1052">1052. else if (!obj->dknown)</span>
  1057. <span id="line1053">1053. objects[otyp].oc_name_known = 0;</span>
  1058. <span id="line1054">1054. </span>
  1059. <span id="line1055">1055. /* caveat: this makes a lot of assumptions about which fields</span>
  1060. <span id="line1056">1056. are required in order for xname() to yield a sensible result */</span>
  1061. <span id="line1057">1057. bareobj = cg.zeroobj;</span>
  1062. <span id="line1058">1058. bareobj.otyp = otyp;</span>
  1063. <span id="line1059">1059. bareobj.oclass = obj->oclass;</span>
  1064. <span id="line1060">1060. /* not observe_object, either the hero observed the object already or this</span>
  1065. <span id="line1061">1061. is overriding ID and shouldn't discover the object */</span>
  1066. <span id="line1062">1062. bareobj.dknown = (obj->dknown || iflags.override_ID) ? 1 : 0;</span>
  1067. <span id="line1063">1063. /* suppress known except for amulets (needed for fakes and real A-of-Y) */</span>
  1068. <span id="line1064">1064. bareobj.known = (obj->oclass == AMULET_CLASS)</span>
  1069. <span id="line1065">1065. ? obj->known</span>
  1070. <span id="line1066">1066. /* default is "on" for types which don't use it */</span>
  1071. <span id="line1067">1067. : !objects[otyp].oc_uses_known;</span>
  1072. <span id="line1068">1068. bareobj.quan = 1L; /* don't want plural */</span>
  1073. <span id="line1069">1069. /* for a boulder, leave corpsenm as 0; non-zero produces "next boulder" */</span>
  1074. <span id="line1070">1070. if (otyp != BOULDER)</span>
  1075. <span id="line1071">1071. bareobj.corpsenm = NON_PM; /* suppress statue and figurine details */</span>
  1076. <span id="line1072">1072. /* but suppressing fruit details leads to "bad fruit #0"</span>
  1077. <span id="line1073">1073. [perhaps we should force "slime mold" rather than use xname?] */</span>
  1078. <span id="line1074">1074. if (obj->otyp == SLIME_MOLD)</span>
  1079. <span id="line1075">1075. bareobj.spe = obj->spe;</span>
  1080. <span id="line1076">1076. </span>
  1081. <span id="line1077">1077. bufp = distant_name(&bareobj, xname);</span>
  1082. <span id="line1078">1078. /* undo forced setting of bareobj.blessed for cleric (priest[ess]);</span>
  1083. <span id="line1079">1079. bufp is an obuf[] so a pointer into the middle of that is viable */</span>
  1084. <span id="line1080">1080. if (!strncmp(bufp, "uncursed ", 9))</span>
  1085. <span id="line1081">1081. bufp += 9;</span>
  1086. <span id="line1082">1082. </span>
  1087. <span id="line1083">1083. objects[otyp].oc_uname = saveobcls.oc_uname;</span>
  1088. <span id="line1084">1084. objects[otyp].oc_name_known = saveobcls.oc_name_known;</span>
  1089. <span id="line1085">1085. return bufp;</span>
  1090. <span id="line1086">1086. }</span>
  1091. <span id="line1087">1087. </span>
  1092. <span id="line1088">1088. /* xname() output augmented for multishot missile feedback */</span>
  1093. <span id="line1089">1089. char *</span>
  1094. <span id="line1090">1090. mshot_xname(struct obj *obj)</span>
  1095. <span id="line1091">1091. {</span>
  1096. <span id="line1092">1092. char tmpbuf[BUFSZ];</span>
  1097. <span id="line1093">1093. char *onm = xname(obj);</span>
  1098. <span id="line1094">1094. </span>
  1099. <span id="line1095">1095. if (gm.m_shot.n > 1 && gm.m_shot.o == obj->otyp) {</span>
  1100. <span id="line1096">1096. /* "the Nth arrow"; value will eventually be passed to an() or</span>
  1101. <span id="line1097">1097. The(), both of which correctly handle this "the " prefix */</span>
  1102. <span id="line1098">1098. Sprintf(tmpbuf, "the %d%s ", gm.m_shot.i, ordin(gm.m_shot.i));</span>
  1103. <span id="line1099">1099. onm = strprepend(onm, tmpbuf);</span>
  1104. <span id="line1100">1100. }</span>
  1105. <span id="line1101">1101. return onm;</span>
  1106. <span id="line1102">1102. }</span>
  1107. <span id="line1103">1103. </span>
  1108. <span id="line1104">1104. /* used for naming "the unique_item" instead of "a unique_item" */</span>
  1109. <span id="line1105">1105. boolean</span>
  1110. <span id="line1106">1106. the_unique_obj(struct obj *obj)</span>
  1111. <span id="line1107">1107. {</span>
  1112. <span id="line1108">1108. boolean known = (obj->known || iflags.override_ID);</span>
  1113. <span id="line1109">1109. </span>
  1114. <span id="line1110">1110. if (!obj->dknown && !iflags.override_ID)</span>
  1115. <span id="line1111">1111. return FALSE;</span>
  1116. <span id="line1112">1112. else if (obj->otyp == FAKE_AMULET_OF_YENDOR && !known)</span>
  1117. <span id="line1113">1113. return TRUE; /* lie */</span>
  1118. <span id="line1114">1114. else</span>
  1119. <span id="line1115">1115. return (boolean) (objects[obj->otyp].oc_unique</span>
  1120. <span id="line1116">1116. && (known || obj->otyp == AMULET_OF_YENDOR));</span>
  1121. <span id="line1117">1117. }</span>
  1122. <span id="line1118">1118. </span>
  1123. <span id="line1119">1119. /* should monster type be prefixed with "the"? (mostly used for corpses) */</span>
  1124. <span id="line1120">1120. boolean</span>
  1125. <span id="line1121">1121. the_unique_pm(struct permonst *ptr)</span>
  1126. <span id="line1122">1122. {</span>
  1127. <span id="line1123">1123. boolean uniq;</span>
  1128. <span id="line1124">1124. </span>
  1129. <span id="line1125">1125. /* even though monsters with personal names are unique, we want to</span>
  1130. <span id="line1126">1126. describe them as "Name" rather than "the Name" */</span>
  1131. <span id="line1127">1127. if (type_is_pname(ptr))</span>
  1132. <span id="line1128">1128. return FALSE;</span>
  1133. <span id="line1129">1129. </span>
  1134. <span id="line1130">1130. uniq = (ptr->geno & G_UNIQ) ? TRUE : FALSE;</span>
  1135. <span id="line1131">1131. /* high priest is unique if it includes "of <deity>", otherwise not</span>
  1136. <span id="line1132">1132. (caller needs to handle the 1st possibility; we assume the 2nd);</span>
  1137. <span id="line1133">1133. worm tail should be irrelevant but is included for completeness */</span>
  1138. <span id="line1134">1134. if (ptr == &mons[PM_HIGH_CLERIC] || ptr == &mons[PM_LONG_WORM_TAIL])</span>
  1139. <span id="line1135">1135. uniq = FALSE;</span>
  1140. <span id="line1136">1136. /* Wizard no longer needs this; he's flagged as unique these days */</span>
  1141. <span id="line1137">1137. if (ptr == &mons[PM_WIZARD_OF_YENDOR])</span>
  1142. <span id="line1138">1138. uniq = TRUE;</span>
  1143. <span id="line1139">1139. return uniq;</span>
  1144. <span id="line1140">1140. }</span>
  1145. <span id="line1141">1141. </span>
  1146. <span id="line1142">1142. staticfn void</span>
  1147. <span id="line1143">1143. add_erosion_words(struct obj *obj, char *prefix)</span>
  1148. <span id="line1144">1144. {</span>
  1149. <span id="line1145">1145. boolean iscrys = (obj->otyp == CRYSKNIFE);</span>
  1150. <span id="line1146">1146. boolean rknown;</span>
  1151. <span id="line1147">1147. </span>
  1152. <span id="line1148">1148. rknown = (iflags.override_ID == 0) ? obj->rknown : TRUE;</span>
  1153. <span id="line1149">1149. </span>
  1154. <span id="line1150">1150. if (!is_damageable(obj) && !iscrys)</span>
  1155. <span id="line1151">1151. return;</span>
  1156. <span id="line1152">1152. </span>
  1157. <span id="line1153">1153. /* The only cases where any of these bits do double duty are for</span>
  1158. <span id="line1154">1154. * rotted food and diluted potions, which are all not is_damageable().</span>
  1159. <span id="line1155">1155. */</span>
  1160. <span id="line1156">1156. if (obj->oeroded && !iscrys) {</span>
  1161. <span id="line1157">1157. switch (obj->oeroded) {</span>
  1162. <span id="line1158">1158. case 2:</span>
  1163. <span id="line1159">1159. Strcat(prefix, "very ");</span>
  1164. <span id="line1160">1160. break;</span>
  1165. <span id="line1161">1161. case 3:</span>
  1166. <span id="line1162">1162. Strcat(prefix, "thoroughly ");</span>
  1167. <span id="line1163">1163. break;</span>
  1168. <span id="line1164">1164. }</span>
  1169. <span id="line1165">1165. Strcat(prefix, is_rustprone(obj) ? "rusty "</span>
  1170. <span id="line1166">1166. : is_crackable(obj) ? "cracked "</span>
  1171. <span id="line1167">1167. : "burnt ");</span>
  1172. <span id="line1168">1168. }</span>
  1173. <span id="line1169">1169. if (obj->oeroded2 && !iscrys) {</span>
  1174. <span id="line1170">1170. switch (obj->oeroded2) {</span>
  1175. <span id="line1171">1171. case 2:</span>
  1176. <span id="line1172">1172. Strcat(prefix, "very ");</span>
  1177. <span id="line1173">1173. break;</span>
  1178. <span id="line1174">1174. case 3:</span>
  1179. <span id="line1175">1175. Strcat(prefix, "thoroughly ");</span>
  1180. <span id="line1176">1176. break;</span>
  1181. <span id="line1177">1177. }</span>
  1182. <span id="line1178">1178. Strcat(prefix, is_corrodeable(obj) ? "corroded " : "rotted ");</span>
  1183. <span id="line1179">1179. }</span>
  1184. <span id="line1180">1180. /* note: it is possible for an item to be both eroded and erodeproof</span>
  1185. <span id="line1181">1181. (cursed scroll of destroy armor read while confused erodeproofs an</span>
  1186. <span id="line1182">1182. item of armor without repairing existing erosion) */</span>
  1187. <span id="line1183">1183. if (rknown && obj->oerodeproof)</span>
  1188. <span id="line1184">1184. Strcat(prefix, iscrys ? "fixed "</span>
  1189. <span id="line1185">1185. : is_rustprone(obj) ? "rustproof "</span>
  1190. <span id="line1186">1186. : is_corrodeable(obj) ? "corrodeproof "</span>
  1191. <span id="line1187">1187. : is_flammable(obj) ? "fireproof "</span>
  1192. <span id="line1188">1188. : is_crackable(obj) ? "tempered " /* hardened */</span>
  1193. <span id="line1189">1189. : is_rottable(obj) ? "rotproof "</span>
  1194. <span id="line1190">1190. : "");</span>
  1195. <span id="line1191">1191. }</span>
  1196. <span id="line1192">1192. </span>
  1197. <span id="line1193">1193. /* used to prevent rust on items where rust makes no difference */</span>
  1198. <span id="line1194">1194. boolean</span>
  1199. <span id="line1195">1195. erosion_matters(struct obj *obj)</span>
  1200. <span id="line1196">1196. {</span>
  1201. <span id="line1197">1197. switch (obj->oclass) {</span>
  1202. <span id="line1198">1198. case TOOL_CLASS:</span>
  1203. <span id="line1199">1199. /* it's possible for a rusty weptool to be polymorphed into some</span>
  1204. <span id="line1200">1200. non-weptool iron tool, in which case the rust implicitly goes</span>
  1205. <span id="line1201">1201. away, but it's also possible for it to be polymorphed into a</span>
  1206. <span id="line1202">1202. non-iron tool, in which case rust also implicitly goes away,</span>
  1207. <span id="line1203">1203. so there's no particular reason to try to handle the first</span>
  1208. <span id="line1204">1204. instance differently [this comment belongs in poly_obj()...] */</span>
  1209. <span id="line1205">1205. return is_weptool(obj) ? TRUE : FALSE;</span>
  1210. <span id="line1206">1206. case WEAPON_CLASS:</span>
  1211. <span id="line1207">1207. case ARMOR_CLASS:</span>
  1212. <span id="line1208">1208. case BALL_CLASS:</span>
  1213. <span id="line1209">1209. case CHAIN_CLASS:</span>
  1214. <span id="line1210">1210. return TRUE;</span>
  1215. <span id="line1211">1211. default:</span>
  1216. <span id="line1212">1212. break;</span>
  1217. <span id="line1213">1213. }</span>
  1218. <span id="line1214">1214. return FALSE;</span>
  1219. <span id="line1215">1215. }</span>
  1220. <span id="line1216">1216. </span>
  1221. <span id="line1217">1217. #define DONAME_WITH_PRICE 1</span>
  1222. <span id="line1218">1218. #define DONAME_VAGUE_QUAN 2</span>
  1223. <span id="line1219">1219. #define DONAME_FOR_MENU 4 /* [not used anywhere yet] */</span>
  1224. <span id="line1220">1220. </span>
  1225. <span id="line1221">1221. /* core of doname() */</span>
  1226. <span id="line1222">1222. staticfn char *</span>
  1227. <span id="line1223">1223. doname_base(</span>
  1228. <span id="line1224">1224. struct obj *obj, /* object to format */</span>
  1229. <span id="line1225">1225. unsigned doname_flags) /* special case requests */</span>
  1230. <span id="line1226">1226. {</span>
  1231. <span id="line1227">1227. boolean ispoisoned = FALSE,</span>
  1232. <span id="line1228">1228. with_price = (doname_flags & DONAME_WITH_PRICE) != 0,</span>
  1233. <span id="line1229">1229. vague_quan = (doname_flags & DONAME_VAGUE_QUAN) != 0,</span>
  1234. <span id="line1230">1230. for_menu = (doname_flags & DONAME_FOR_MENU) != 0;</span>
  1235. <span id="line1231">1231. boolean known, dknown, cknown, bknown, lknown,</span>
  1236. <span id="line1232">1232. fake_arti, force_the;</span>
  1237. <span id="line1233">1233. char prefix[PREFIX];</span>
  1238. <span id="line1234">1234. char tmpbuf[PREFIX + 1]; /* for when we have to add something at</span>
  1239. <span id="line1235">1235. * the start of prefix instead of the</span>
  1240. <span id="line1236">1236. * end (Strcat is used on the end) */</span>
  1241. <span id="line1237">1237. const char *aname = 0;</span>
  1242. <span id="line1238">1238. int omndx = obj->corpsenm;</span>
  1243. <span id="line1239">1239. char *bp;</span>
  1244. <span id="line1240">1240. char *bp_eos, *bp_end;</span>
  1245. <span id="line1241">1241. size_t bpspaceleft;</span>
  1246. <span id="line1242">1242. </span>
  1247. <span id="line1243">1243. /* 'bp' will be within an obuf[] rather than at the start of one,</span>
  1248. <span id="line1244">1244. usually (but not always) pointing at &obuf[PREFIX];</span>
  1249. <span id="line1245">1245. gx.xnamep always points to the start of that buffer;</span>
  1250. <span id="line1246">1246. 'bp_eos' and 'bpspaceleft' are used and updated by Concat*() macros */</span>
  1251. <span id="line1247">1247. bp = xname(obj);</span>
  1252. <span id="line1248">1248. bp_end = gx.xnamep + BUFSZ - 1;</span>
  1253. <span id="line1249">1249. bp_eos = eos(bp);</span>
  1254. <span id="line1250">1250. assert(bp_end >= bp_eos); /* ok provided xname() bounds checking works */</span>
  1255. <span id="line1251">1251. /* size_t cast: convert signed ptrdiff_t to unsigned size_t */</span>
  1256. <span id="line1252">1252. bpspaceleft = (size_t) (bp_end - bp_eos);</span>
  1257. <span id="line1253">1253. </span>
  1258. <span id="line1254">1254. if (iflags.override_ID) {</span>
  1259. <span id="line1255">1255. known = dknown = cknown = bknown = lknown = TRUE;</span>
  1260. <span id="line1256">1256. } else {</span>
  1261. <span id="line1257">1257. known = obj->known;</span>
  1262. <span id="line1258">1258. dknown = obj->dknown;</span>
  1263. <span id="line1259">1259. cknown = obj->cknown;</span>
  1264. <span id="line1260">1260. bknown = obj->bknown;</span>
  1265. <span id="line1261">1261. lknown = obj->lknown;</span>
  1266. <span id="line1262">1262. }</span>
  1267. <span id="line1263">1263. </span>
  1268. <span id="line1264">1264. /* When using xname, we want "poisoned arrow", and when using</span>
  1269. <span id="line1265">1265. * doname, we want "poisoned +0 arrow". This kludge is about the only</span>
  1270. <span id="line1266">1266. * way to do it, at least until someone overhauls xname() and doname(),</span>
  1271. <span id="line1267">1267. * combining both into one function taking a parameter.</span>
  1272. <span id="line1268">1268. */</span>
  1273. <span id="line1269">1269. /* must check opoisoned--someone can have a weirdly-named fruit */</span>
  1274. <span id="line1270">1270. if (!strncmp(bp, "poisoned ", 9) && obj->opoisoned) {</span>
  1275. <span id="line1271">1271. bp += 9; /* doesn't affect bp_eos or bpspaceleft */</span>
  1276. <span id="line1272">1272. ispoisoned = TRUE;</span>
  1277. <span id="line1273">1273. }</span>
  1278. <span id="line1274">1274. </span>
  1279. <span id="line1275">1275. /* fruits are allowed to be given artifact names; when that happens,</span>
  1280. <span id="line1276">1276. format the name like the corresponding artifact, which may or may not</span>
  1281. <span id="line1277">1277. want "the" prefix and when it doesn't, avoid "a"/"an" prefix too */</span>
  1282. <span id="line1278">1278. fake_arti = (obj->otyp == SLIME_MOLD</span>
  1283. <span id="line1279">1279. && (aname = artifact_name(bp, (short *) 0, FALSE)) != 0);</span>
  1284. <span id="line1280">1280. force_the = (fake_arti && !strncmpi(aname, "the ", 4));</span>
  1285. <span id="line1281">1281. </span>
  1286. <span id="line1282">1282. prefix[0] = '\0';</span>
  1287. <span id="line1283">1283. if (obj->quan != 1L) {</span>
  1288. <span id="line1284">1284. if (dknown || !vague_quan)</span>
  1289. <span id="line1285">1285. Sprintf(prefix, "%ld ", obj->quan);</span>
  1290. <span id="line1286">1286. else</span>
  1291. <span id="line1287">1287. Strcpy(prefix, "some ");</span>
  1292. <span id="line1288">1288. } else if (obj->otyp == CORPSE) {</span>
  1293. <span id="line1289">1289. /* skip article prefix for corpses [else corpse_xname()</span>
  1294. <span id="line1290">1290. would have to be taught how to strip it off again] */</span>
  1295. <span id="line1291">1291. ;</span>
  1296. <span id="line1292">1292. } else if (force_the || obj_is_pname(obj) || the_unique_obj(obj)) {</span>
  1297. <span id="line1293">1293. if (!strncmpi(bp, "the ", 4))</span>
  1298. <span id="line1294">1294. bp += 4; /* doesn't affect bp_eos or bpspaceleft */</span>
  1299. <span id="line1295">1295. Strcpy(prefix, "the ");</span>
  1300. <span id="line1296">1296. } else if (!fake_arti) {</span>
  1301. <span id="line1297">1297. /* default prefix */</span>
  1302. <span id="line1298">1298. Strcpy(prefix, "a ");</span>
  1303. <span id="line1299">1299. }</span>
  1304. <span id="line1300">1300. </span>
  1305. <span id="line1301">1301. /* "empty" goes at the beginning, but item count goes at the end */</span>
  1306. <span id="line1302">1302. if (cknown</span>
  1307. <span id="line1303">1303. /* bag of tricks: include "empty" prefix if it's known to</span>
  1308. <span id="line1304">1304. be empty but its precise number of charges isn't known</span>
  1309. <span id="line1305">1305. (when that is known, suffix of "(n:0)" will be appended,</span>
  1310. <span id="line1306">1306. making the prefix be redundant; note that 'known' flag</span>
  1311. <span id="line1307">1307. isn't set when emptiness gets discovered because then</span>
  1312. <span id="line1308">1308. charging magic would yield known number of new charges);</span>
  1313. <span id="line1309">1309. horn of plenty isn't a container but is close enough */</span>
  1314. <span id="line1310">1310. && ((obj->otyp == BAG_OF_TRICKS || obj->otyp == HORN_OF_PLENTY)</span>
  1315. <span id="line1311">1311. ? (obj->spe == 0 && !known)</span>
  1316. <span id="line1312">1312. /* not a bag of tricks or horn of plenty: it's empty if</span>
  1317. <span id="line1313">1313. it is a container that has no contents */</span>
  1318. <span id="line1314">1314. : ((Is_container(obj) || obj->otyp == STATUE)</span>
  1319. <span id="line1315">1315. && !Has_contents(obj))))</span>
  1320. <span id="line1316">1316. Strcat(prefix, "empty ");</span>
  1321. <span id="line1317">1317. </span>
  1322. <span id="line1318">1318. if (bknown && obj->oclass != COIN_CLASS</span>
  1323. <span id="line1319">1319. && (obj->otyp != POT_WATER || !objects[POT_WATER].oc_name_known</span>
  1324. <span id="line1320">1320. || (!obj->cursed && !obj->blessed))) {</span>
  1325. <span id="line1321">1321. /* allow 'blessed clear potion' if we don't know it's holy water;</span>
  1326. <span id="line1322">1322. * always allow "uncursed potion of water"</span>
  1327. <span id="line1323">1323. */</span>
  1328. <span id="line1324">1324. if (obj->cursed)</span>
  1329. <span id="line1325">1325. Strcat(prefix, "cursed ");</span>
  1330. <span id="line1326">1326. else if (obj->blessed)</span>
  1331. <span id="line1327">1327. Strcat(prefix, "blessed ");</span>
  1332. <span id="line1328">1328. else if (!flags.implicit_uncursed</span>
  1333. <span id="line1329">1329. /* For most items with charges or +/-, if you know how many</span>
  1334. <span id="line1330">1330. * charges are left or what the +/- is, then you must have</span>
  1335. <span id="line1331">1331. * totally identified the item, so "uncursed" is unnecessary,</span>
  1336. <span id="line1332">1332. * because an identified object not described as "blessed" or</span>
  1337. <span id="line1333">1333. * "cursed" must be uncursed.</span>
  1338. <span id="line1334">1334. *</span>
  1339. <span id="line1335">1335. * If the charges or +/- is not known, "uncursed" must be</span>
  1340. <span id="line1336">1336. * printed to avoid ambiguity between an item whose curse</span>
  1341. <span id="line1337">1337. * status is unknown, and an item known to be uncursed.</span>
  1342. <span id="line1338">1338. */</span>
  1343. <span id="line1339">1339. || ((!known || !objects[obj->otyp].oc_charged</span>
  1344. <span id="line1340">1340. || obj->oclass == ARMOR_CLASS</span>
  1345. <span id="line1341">1341. || obj->oclass == RING_CLASS)</span>
  1346. <span id="line1342">1342. #ifdef MAIL_STRUCTURES</span>
  1347. <span id="line1343">1343. && obj->otyp != SCR_MAIL</span>
  1348. <span id="line1344">1344. #endif</span>
  1349. <span id="line1345">1345. && obj->otyp != FAKE_AMULET_OF_YENDOR</span>
  1350. <span id="line1346">1346. && obj->otyp != AMULET_OF_YENDOR</span>
  1351. <span id="line1347">1347. && !Role_if(PM_CLERIC)))</span>
  1352. <span id="line1348">1348. Strcat(prefix, "uncursed ");</span>
  1353. <span id="line1349">1349. }</span>
  1354. <span id="line1350">1350. </span>
  1355. <span id="line1351">1351. /* "a large trapped box" would perhaps be more correct; [no!]</span>
  1356. <span id="line1352">1352. what about ``(obj->tknown && !obj->otrapped)''? shouldn't that</span>
  1357. <span id="line1353">1353. yield "a non-trapped large box"? (not "an untrapped large box");</span>
  1358. <span id="line1354">1354. TODO: this should be ``(Is_box(obj) || obj->otyp == TIN) && ...''</span>
  1359. <span id="line1355">1355. but at present there's no way to set obj->tknown for tins */</span>
  1360. <span id="line1356">1356. if (Is_box(obj) && obj->otrapped && obj->tknown && obj->dknown)</span>
  1361. <span id="line1357">1357. Strcat(prefix,"trapped ");</span>
  1362. <span id="line1358">1358. if (lknown && Is_box(obj)) {</span>
  1363. <span id="line1359">1359. if (obj->obroken)</span>
  1364. <span id="line1360">1360. /* 3.6.0 used "unlockable" here but that could be misunderstood</span>
  1365. <span id="line1361">1361. to mean "capable of being unlocked" rather than the intended</span>
  1366. <span id="line1362">1362. "not capable of being locked" */</span>
  1367. <span id="line1363">1363. Strcat(prefix, "broken ");</span>
  1368. <span id="line1364">1364. else if (obj->olocked)</span>
  1369. <span id="line1365">1365. Strcat(prefix, "locked ");</span>
  1370. <span id="line1366">1366. else</span>
  1371. <span id="line1367">1367. Strcat(prefix, "unlocked ");</span>
  1372. <span id="line1368">1368. }</span>
  1373. <span id="line1369">1369. </span>
  1374. <span id="line1370">1370. if (obj->greased)</span>
  1375. <span id="line1371">1371. Strcat(prefix, "greased ");</span>
  1376. <span id="line1372">1372. </span>
  1377. <span id="line1373">1373. if (cknown && Has_contents(obj) && bpspaceleft > 0) {</span>
  1378. <span id="line1374">1374. /* we count the number of separate stacks, which corresponds</span>
  1379. <span id="line1375">1375. to the number of inventory slots needed to be able to take</span>
  1380. <span id="line1376">1376. everything out if no merges occur */</span>
  1381. <span id="line1377">1377. long itemcount = count_contents(obj, FALSE, FALSE, TRUE, FALSE);</span>
  1382. <span id="line1378">1378. </span>
  1383. <span id="line1379">1379. ConcatF2(bp, 0, " containing %ld item%s", itemcount, plur(itemcount));</span>
  1384. <span id="line1380">1380. }</span>
  1385. <span id="line1381">1381. </span>
  1386. <span id="line1382">1382. switch (is_weptool(obj) ? WEAPON_CLASS : obj->oclass) {</span>
  1387. <span id="line1383">1383. case AMULET_CLASS:</span>
  1388. <span id="line1384">1384. if (obj->owornmask & W_AMUL)</span>
  1389. <span id="line1385">1385. Concat(bp, 0, " (being worn)");</span>
  1390. <span id="line1386">1386. break;</span>
  1391. <span id="line1387">1387. case ARMOR_CLASS:</span>
  1392. <span id="line1388">1388. if (obj->owornmask & W_ARMOR) {</span>
  1393. <span id="line1389">1389. Concat(bp, 0,</span>
  1394. <span id="line1390">1390. (obj == uskin) ? " (embedded in your skin)"</span>
  1395. <span id="line1391">1391. /* in case of perm_invent update while Wear/Takeoff</span>
  1396. <span id="line1392">1392. is in progress; check doffing() before donning()</span>
  1397. <span id="line1393">1393. because donning() returns True for both cases */</span>
  1398. <span id="line1394">1394. : doffing(obj) ? " (being doffed)"</span>
  1399. <span id="line1395">1395. : donning(obj) ? " (being donned)"</span>
  1400. <span id="line1396">1396. : " (being worn)");</span>
  1401. <span id="line1397">1397. /* we just added a parenthesized phrase, but the right paren</span>
  1402. <span id="line1398">1398. might be absent if the appended string got truncated */</span>
  1403. <span id="line1399">1399. if (bp_eos[-1] == ')') {</span>
  1404. <span id="line1400">1400. /* slippery fingers is an intrinsic condition of the hero</span>
  1405. <span id="line1401">1401. rather than extrinsic condition of objects, but gloves</span>
  1406. <span id="line1402">1402. are described as slippery when hero has slippery fingers */</span>
  1407. <span id="line1403">1403. if (obj == uarmg && Glib) /* just appended "(something)",</span>
  1408. <span id="line1404">1404. * replace paren, changing that</span>
  1409. <span id="line1405">1405. * to be "(something; slippery)" */</span>
  1410. <span id="line1406">1406. Concat(bp, 1, "; slippery)");</span>
  1411. <span id="line1407">1407. }</span>
  1412. <span id="line1408">1408. if (bp_eos[-1] == ')') {</span>
  1413. <span id="line1409">1409. /* there could be light-emitting artifact gloves someday,</span>
  1414. <span id="line1410">1410. so add 'lit' separately from 'slippery' rather than via</span>
  1415. <span id="line1411">1411. 'else if' after uarmg+Glib */</span>
  1416. <span id="line1412">1412. if (!Blind && obj->lamplit && artifact_light(obj))</span>
  1417. <span id="line1413">1413. ConcatF1(bp, 1, ", %s lit)", arti_light_description(obj));</span>
  1418. <span id="line1414">1414. }</span>
  1419. <span id="line1415">1415. }</span>
  1420. <span id="line1416">1416. FALLTHROUGH;</span>
  1421. <span id="line1417">1417. /*FALLTHRU*/</span>
  1422. <span id="line1418">1418. case WEAPON_CLASS:</span>
  1423. <span id="line1419">1419. if (ispoisoned)</span>
  1424. <span id="line1420">1420. Strcat(prefix, "poisoned ");</span>
  1425. <span id="line1421">1421. add_erosion_words(obj, prefix);</span>
  1426. <span id="line1422">1422. if (known) {</span>
  1427. <span id="line1423">1423. Sprintf(eos(prefix), "%+d ", obj->spe); /* sitoa(obj->spe)+" " */</span>
  1428. <span id="line1424">1424. }</span>
  1429. <span id="line1425">1425. break;</span>
  1430. <span id="line1426">1426. case TOOL_CLASS:</span>
  1431. <span id="line1427">1427. if (obj->owornmask & (W_TOOL | W_SADDLE)) { /* blindfold */</span>
  1432. <span id="line1428">1428. Concat(bp, 0, " (being worn)");</span>
  1433. <span id="line1429">1429. break;</span>
  1434. <span id="line1430">1430. }</span>
  1435. <span id="line1431">1431. if (obj->otyp == LEASH && obj->leashmon != 0) {</span>
  1436. <span id="line1432">1432. struct monst *mlsh = find_mid(obj->leashmon, FM_FMON);</span>
  1437. <span id="line1433">1433. </span>
  1438. <span id="line1434">1434. if (mlsh && !DEADMONSTER(mlsh)) {</span>
  1439. <span id="line1435">1435. ConcatF1(bp, 0, " (attached to %s)", noit_mon_nam(mlsh));</span>
  1440. <span id="line1436">1436. } else {</span>
  1441. <span id="line1437">1437. if (mlsh) /*&& DEADMONSTER(mlsh)*/</span>
  1442. <span id="line1438">1438. impossible("leashed %s #%u is dead",</span>
  1443. <span id="line1439">1439. mon_pmname(mlsh), (unsigned) obj->leashmon);</span>
  1444. <span id="line1440">1440. else</span>
  1445. <span id="line1441">1441. impossible("leashed monster #%u not found",</span>
  1446. <span id="line1442">1442. (unsigned) obj->leashmon);</span>
  1447. <span id="line1443">1443. obj->leashmon = 0;</span>
  1448. <span id="line1444">1444. }</span>
  1449. <span id="line1445">1445. break;</span>
  1450. <span id="line1446">1446. }</span>
  1451. <span id="line1447">1447. if (obj->otyp == CANDELABRUM_OF_INVOCATION) {</span>
  1452. <span id="line1448">1448. char suffix[20]; /* longest value is "s attached" */</span>
  1453. <span id="line1449">1449. </span>
  1454. <span id="line1450">1450. /* separately formatted suffix avoids need for ConcatF3() */</span>
  1455. <span id="line1451">1451. Sprintf(suffix, "%s%s", plur(obj->spe),</span>
  1456. <span id="line1452">1452. !obj->lamplit ? " attached" : ", lit");</span>
  1457. <span id="line1453">1453. ConcatF2(bp, 0, " (%d of 7 candle%s)", obj->spe, suffix);</span>
  1458. <span id="line1454">1454. break;</span>
  1459. <span id="line1455">1455. } else if (obj->otyp == OIL_LAMP || obj->otyp == MAGIC_LAMP</span>
  1460. <span id="line1456">1456. || obj->otyp == BRASS_LANTERN || Is_candle(obj)) {</span>
  1461. <span id="line1457">1457. if (Is_candle(obj)) {</span>
  1462. <span id="line1458">1458. anything timer;</span>
  1463. <span id="line1459">1459. long full_burn_time = 20L * (long) objects[obj->otyp].oc_cost,</span>
  1464. <span id="line1460">1460. turns_left = obj->age;</span>
  1465. <span id="line1461">1461. </span>
  1466. <span id="line1462">1462. if (obj->lamplit) {</span>
  1467. <span id="line1463">1463. timer = cg.zeroany;</span>
  1468. <span id="line1464">1464. timer.a_obj = obj;</span>
  1469. <span id="line1465">1465. /* without this, wishing for "lit candle" yields</span>
  1470. <span id="line1466">1466. "partly used candle (lit)" because the time it can</span>
  1471. <span id="line1467">1467. burn gets adjusted when it becomes lit; matters for</span>
  1472. <span id="line1468">1468. the message as it gets added to invent and also if it</span>
  1473. <span id="line1469">1469. gets snuffed out immediately (where it will end up as</span>
  1474. <span id="line1470">1470. not partly used after all) */</span>
  1475. <span id="line1471">1471. turns_left += peek_timer(BURN_OBJECT, &timer) - svm.moves;</span>
  1476. <span id="line1472">1472. }</span>
  1477. <span id="line1473">1473. if (turns_left < full_burn_time)</span>
  1478. <span id="line1474">1474. Strcat(prefix, "partly used ");</span>
  1479. <span id="line1475">1475. }</span>
  1480. <span id="line1476">1476. if (obj->lamplit)</span>
  1481. <span id="line1477">1477. Concat(bp, 0, " (lit)");</span>
  1482. <span id="line1478">1478. break;</span>
  1483. <span id="line1479">1479. }</span>
  1484. <span id="line1480">1480. if (objects[obj->otyp].oc_charged)</span>
  1485. <span id="line1481">1481. goto charges;</span>
  1486. <span id="line1482">1482. break;</span>
  1487. <span id="line1483">1483. case WAND_CLASS:</span>
  1488. <span id="line1484">1484. charges:</span>
  1489. <span id="line1485">1485. if (known)</span>
  1490. <span id="line1486">1486. ConcatF2(bp, 0, " (%d:%d)", (int) obj->recharged, obj->spe);</span>
  1491. <span id="line1487">1487. break;</span>
  1492. <span id="line1488">1488. case POTION_CLASS:</span>
  1493. <span id="line1489">1489. if (obj->otyp == POT_OIL && obj->lamplit)</span>
  1494. <span id="line1490">1490. Concat(bp, 0, " (lit)");</span>
  1495. <span id="line1491">1491. break;</span>
  1496. <span id="line1492">1492. case RING_CLASS:</span>
  1497. <span id="line1493">1493. ring: /* normal rings reach here 'naturally'; meat ring jumps here */</span>
  1498. <span id="line1494">1494. if (obj->owornmask & W_RINGR)</span>
  1499. <span id="line1495">1495. Concat(bp, 0, " (on right ");</span>
  1500. <span id="line1496">1496. if (obj->owornmask & W_RINGL)</span>
  1501. <span id="line1497">1497. Concat(bp, 0, " (on left ");</span>
  1502. <span id="line1498">1498. if (obj->owornmask & W_RING) /* either left or right */</span>
  1503. <span id="line1499">1499. ConcatF1(bp, 0,"%s)", body_part(HAND));</span>
  1504. <span id="line1500">1500. if (known && objects[obj->otyp].oc_charged) {</span>
  1505. <span id="line1501">1501. Sprintf(eos(prefix), "%+d ", obj->spe); /* sitoa(obj->spe)+" " */</span>
  1506. <span id="line1502">1502. }</span>
  1507. <span id="line1503">1503. break;</span>
  1508. <span id="line1504">1504. case FOOD_CLASS:</span>
  1509. <span id="line1505">1505. if (obj->oeaten)</span>
  1510. <span id="line1506">1506. Strcat(prefix, "partly eaten ");</span>
  1511. <span id="line1507">1507. if (obj->otyp == CORPSE) {</span>
  1512. <span id="line1508">1508. /* (quan == 1) => want corpse_xname() to supply article,</span>
  1513. <span id="line1509">1509. (quan != 1) => already have count or "some" as prefix;</span>
  1514. <span id="line1510">1510. "corpse" is already in the buffer returned by xname() */</span>
  1515. <span id="line1511">1511. unsigned cxarg = (((obj->quan != 1L) ? 0 : CXN_ARTICLE)</span>
  1516. <span id="line1512">1512. | CXN_NOCORPSE);</span>
  1517. <span id="line1513">1513. char *cxstr, *save_xnamep;</span>
  1518. <span id="line1514">1514. </span>
  1519. <span id="line1515">1515. /* corpse_xname() sets xnamep; callers other than doname_base()</span>
  1520. <span id="line1516">1516. itself shouldn't care about xnamep (pointer to start of</span>
  1521. <span id="line1517">1517. current obuf[]) but keep it accurate anyway */</span>
  1522. <span id="line1518">1518. save_xnamep = gx.xnamep;</span>
  1523. <span id="line1519">1519. cxstr = corpse_xname(obj, prefix, cxarg);</span>
  1524. <span id="line1520">1520. Sprintf(prefix, "%s ", cxstr);</span>
  1525. <span id="line1521">1521. /* avoid having doname(corpse) consume an extra obuf */</span>
  1526. <span id="line1522">1522. releaseobuf(cxstr);</span>
  1527. <span id="line1523">1523. gx.xnamep = save_xnamep;</span>
  1528. <span id="line1524">1524. } else if (obj->otyp == EGG) {</span>
  1529. <span id="line1525">1525. #if 0 /* corpses don't tell if they're stale either */</span>
  1530. <span id="line1526">1526. if (known && stale_egg(obj))</span>
  1531. <span id="line1527">1527. Strcat(prefix, "stale ");</span>
  1532. <span id="line1528">1528. #endif</span>
  1533. <span id="line1529">1529. if (ismnum(omndx)</span>
  1534. <span id="line1530">1530. && (known || (svm.mvitals[omndx].mvflags & MV_KNOWS_EGG))) {</span>
  1535. <span id="line1531">1531. Strcat(prefix, mons[omndx].pmnames[NEUTRAL]);</span>
  1536. <span id="line1532">1532. Strcat(prefix, " ");</span>
  1537. <span id="line1533">1533. if (obj->spe == 1)</span>
  1538. <span id="line1534">1534. Concat(bp, 0, " (laid by you)");</span>
  1539. <span id="line1535">1535. }</span>
  1540. <span id="line1536">1536. } else if (obj->otyp == MEAT_RING) {</span>
  1541. <span id="line1537">1537. goto ring;</span>
  1542. <span id="line1538">1538. }</span>
  1543. <span id="line1539">1539. break;</span>
  1544. <span id="line1540">1540. case BALL_CLASS:</span>
  1545. <span id="line1541">1541. case CHAIN_CLASS:</span>
  1546. <span id="line1542">1542. add_erosion_words(obj, prefix);</span>
  1547. <span id="line1543">1543. if (obj->owornmask & (W_BALL | W_CHAIN))</span>
  1548. <span id="line1544">1544. ConcatF1(bp, 0, " (%s to you)",</span>
  1549. <span id="line1545">1545. (obj->owornmask & W_BALL) ? "chained" : "attached");</span>
  1550. <span id="line1546">1546. break;</span>
  1551. <span id="line1547">1547. }</span>
  1552. <span id="line1548">1548. </span>
  1553. <span id="line1549">1549. if ((obj->otyp == STATUE || obj->otyp == CORPSE || obj->otyp == FIGURINE)</span>
  1554. <span id="line1550">1550. && wizard && iflags.wizmgender) {</span>
  1555. <span id="line1551">1551. int cgend = (obj->spe & CORPSTAT_GENDER),</span>
  1556. <span id="line1552">1552. mgend = ((cgend == CORPSTAT_MALE) ? MALE</span>
  1557. <span id="line1553">1553. : (cgend == CORPSTAT_FEMALE) ? FEMALE</span>
  1558. <span id="line1554">1554. : NEUTRAL);</span>
  1559. <span id="line1555">1555. </span>
  1560. <span id="line1556">1556. ConcatF1(bp, 0, " (%s)",</span>
  1561. <span id="line1557">1557. (cgend != CORPSTAT_RANDOM) ? genders[mgend].adj</span>
  1562. <span id="line1558">1558. : "unspecified gender");</span>
  1563. <span id="line1559">1559. }</span>
  1564. <span id="line1560">1560. </span>
  1565. <span id="line1561">1561. if ((obj->owornmask & W_WEP) && !gm.mrg_to_wielded) {</span>
  1566. <span id="line1562">1562. boolean twoweap_primary = (obj == uwep && u.twoweap),</span>
  1567. <span id="line1563">1563. tethered = (obj->otyp == AKLYS);</span>
  1568. <span id="line1564">1564. </span>
  1569. <span id="line1565">1565. </span>
  1570. <span id="line1566">1566. /* use alternate phrasing for non-weapons and for wielded ammo</span>
  1571. <span id="line1567">1567. (arrows, bolts), or missiles (darts, shuriken, boomerangs)</span>
  1572. <span id="line1568">1568. except when those are being actively dual-wielded where the</span>
  1573. <span id="line1569">1569. regular phrasing will list them as "in right hand" to</span>
  1574. <span id="line1570">1570. contrast with secondary weapon's "in left hand" */</span>
  1575. <span id="line1571">1571. if ((obj->quan != 1L</span>
  1576. <span id="line1572">1572. || ((obj->oclass == WEAPON_CLASS)</span>
  1577. <span id="line1573">1573. ? (is_ammo(obj) || is_missile(obj))</span>
  1578. <span id="line1574">1574. : !is_weptool(obj)))</span>
  1579. <span id="line1575">1575. && !twoweap_primary) {</span>
  1580. <span id="line1576">1576. Concat(bp, 0, " (wielded)");</span>
  1581. <span id="line1577">1577. } else {</span>
  1582. <span id="line1578">1578. const char *hand_s = body_part(HAND);</span>
  1583. <span id="line1579">1579. char *obufp, handsbuf[40];</span>
  1584. <span id="line1580">1580. </span>
  1585. <span id="line1581">1581. if (bimanual(obj)) { /* "hands" */</span>
  1586. <span id="line1582">1582. hand_s = strcpy(handsbuf, obufp = makeplural(hand_s));</span>
  1587. <span id="line1583">1583. releaseobuf(obufp);</span>
  1588. <span id="line1584">1584. } else { /* "right hand" or "left hand" */</span>
  1589. <span id="line1585">1585. Sprintf(handsbuf, "%s %s",</span>
  1590. <span id="line1586">1586. URIGHTY ? "right" : "left", hand_s);</span>
  1591. <span id="line1587">1587. hand_s = handsbuf;</span>
  1592. <span id="line1588">1588. }</span>
  1593. <span id="line1589">1589. /* note: Sting's glow message, if added, will insert text</span>
  1594. <span id="line1590">1590. in front of "(weapon in hand)"'s closing paren */</span>
  1595. <span id="line1591">1591. ConcatF2(bp, 0, " (%s %s)",</span>
  1596. <span id="line1592">1592. tethered ? "tethered to"</span>
  1597. <span id="line1593">1593. : twoweap_primary ? "wielded in"</span>
  1598. <span id="line1594">1594. : "weapon in",</span>
  1599. <span id="line1595">1595. hand_s);</span>
  1600. <span id="line1596">1596. </span>
  1601. <span id="line1597">1597. /* we just added a parenthesized phrase, but the right paren</span>
  1602. <span id="line1598">1598. might be absent if the appended string got truncated */</span>
  1603. <span id="line1599">1599. if (!Blind && bpspaceleft && bp_eos[-1] == ')') {</span>
  1604. <span id="line1600">1600. if (gw.warn_obj_cnt && obj == uwep</span>
  1605. <span id="line1601">1601. && (EWarn_of_mon & W_WEP) != 0L)</span>
  1606. <span id="line1602">1602. /* we know bp[] ends with ')'; overwrite that */</span>
  1607. <span id="line1603">1603. ConcatF2(bp, 1, ", %s %s)",</span>
  1608. <span id="line1604">1604. glow_verb(gw.warn_obj_cnt, TRUE),</span>
  1609. <span id="line1605">1605. glow_color(obj->oartifact));</span>
  1610. <span id="line1606">1606. else if (obj->lamplit && artifact_light(obj))</span>
  1611. <span id="line1607">1607. /* as above, overwrite known closing paren */</span>
  1612. <span id="line1608">1608. ConcatF1(bp, 1, ", %s lit)",</span>
  1613. <span id="line1609">1609. arti_light_description(obj));</span>
  1614. <span id="line1610">1610. }</span>
  1615. <span id="line1611">1611. }</span>
  1616. <span id="line1612">1612. }</span>
  1617. <span id="line1613">1613. if (obj->owornmask & W_SWAPWEP) {</span>
  1618. <span id="line1614">1614. if (u.twoweap)</span>
  1619. <span id="line1615">1615. ConcatF2(bp, 0, " (wielded in %s %s)",</span>
  1620. <span id="line1616">1616. URIGHTY ? "left" : "right", body_part(HAND));</span>
  1621. <span id="line1617">1617. else</span>
  1622. <span id="line1618">1618. /* TODO: rephrase this when obj isn't a weapon or weptool */</span>
  1623. <span id="line1619">1619. ConcatF1(bp, 0, " (alternate weapon%s; not wielded)",</span>
  1624. <span id="line1620">1620. plur(obj->quan));</span>
  1625. <span id="line1621">1621. }</span>
  1626. <span id="line1622">1622. if (obj->owornmask & W_QUIVER) {</span>
  1627. <span id="line1623">1623. int Qtyp;</span>
  1628. <span id="line1624">1624. </span>
  1629. <span id="line1625">1625. switch (obj->oclass) {</span>
  1630. <span id="line1626">1626. case WEAPON_CLASS:</span>
  1631. <span id="line1627">1627. Qtyp = !is_ammo(obj) ? 3 /* not ammo: "at the ready" */</span>
  1632. <span id="line1628">1628. : (objects[obj->otyp].oc_skill != -P_BOW) ? 2 /* non-bow */</span>
  1633. <span id="line1629">1629. : 1; /* ammo for a bow: "in quiver" */</span>
  1634. <span id="line1630">1630. break;</span>
  1635. <span id="line1631">1631. case RING_CLASS:</span>
  1636. <span id="line1632">1632. case AMULET_CLASS:</span>
  1637. <span id="line1633">1633. case WAND_CLASS:</span>
  1638. <span id="line1634">1634. case COIN_CLASS:</span>
  1639. <span id="line1635">1635. case GEM_CLASS:</span>
  1640. <span id="line1636">1636. Qtyp = 2; /* small, non-bow: "in quiver pouch" */</span>
  1641. <span id="line1637">1637. break;</span>
  1642. <span id="line1638">1638. default: /* odd things */</span>
  1643. <span id="line1639">1639. Qtyp = 3; /* "at the ready" */</span>
  1644. <span id="line1640">1640. break;</span>
  1645. <span id="line1641">1641. }</span>
  1646. <span id="line1642">1642. ConcatF1(bp, 0, " (%s)",</span>
  1647. <span id="line1643">1643. (Qtyp == 1) ? "in quiver"</span>
  1648. <span id="line1644">1644. : (Qtyp == 2) ? "in quiver pouch"</span>
  1649. <span id="line1645">1645. : "at the ready");</span>
  1650. <span id="line1646">1646. }</span>
  1651. <span id="line1647">1647. </span>
  1652. <span id="line1648">1648. /* treat 'restoring' like suppress_price because shopkeeper and</span>
  1653. <span id="line1649">1649. bill might not be available yet while restore is in progress</span>
  1654. <span id="line1650">1650. (objects won't normally be formatted during that time, but if</span>
  1655. <span id="line1651">1651. 'perm_invent' is enabled then they might be [not any more...]) */</span>
  1656. <span id="line1652">1652. if (iflags.suppress_price || program_state.restoring) {</span>
  1657. <span id="line1653">1653. ; /* don't attempt to obtain any shop pricing, even if 'with_price' */</span>
  1658. <span id="line1654">1654. } else if (is_unpaid(obj)) { /* in inventory or in container in invent */</span>
  1659. <span id="line1655">1655. char pricebuf[40];</span>
  1660. <span id="line1656">1656. long quotedprice = unpaid_cost(obj, COST_CONTENTS);</span>
  1661. <span id="line1657">1657. </span>
  1662. <span id="line1658">1658. /* separately formatted suffix avoids need for ConcatF3() */</span>
  1663. <span id="line1659">1659. Sprintf(pricebuf, "%ld %s", quotedprice, currency(quotedprice));</span>
  1664. <span id="line1660">1660. ConcatF2(bp, 0, " (%s, %s)",</span>
  1665. <span id="line1661">1661. obj->unpaid ? "unpaid" : "contents", pricebuf);</span>
  1666. <span id="line1662">1662. </span>
  1667. <span id="line1663">1663. record_price_quote(obj->otyp, quotedprice / obj->quan, TRUE);</span>
  1668. <span id="line1664">1664. } else if (with_price) { /* on floor or in container on floor */</span>
  1669. <span id="line1665">1665. int nochrg = 0;</span>
  1670. <span id="line1666">1666. long price = get_cost_of_shop_item(obj, &nochrg);</span>
  1671. <span id="line1667">1667. </span>
  1672. <span id="line1668">1668. if (price > 0L) {</span>
  1673. <span id="line1669">1669. char pricebuf[40];</span>
  1674. <span id="line1670">1670. </span>
  1675. <span id="line1671">1671. Sprintf(pricebuf, "%ld %s", price, currency(price));</span>
  1676. <span id="line1672">1672. ConcatF2(bp, 0, " (%s, %s)",</span>
  1677. <span id="line1673">1673. nochrg ? "contents" : "for sale", pricebuf);</span>
  1678. <span id="line1674">1674. } else if (nochrg > 0) {</span>
  1679. <span id="line1675">1675. Concat(bp, 0, " (no charge)");</span>
  1680. <span id="line1676">1676. } else if (iflags.pricequotes && !objects[obj->otyp].oc_name_known) {</span>
  1681. <span id="line1677">1677. append_price_quote(bp, &bp_eos, obj->otyp);</span>
  1682. <span id="line1678">1678. }</span>
  1683. <span id="line1679">1679. </span>
  1684. <span id="line1680">1680. if (price > 0L)</span>
  1685. <span id="line1681">1681. record_price_quote(obj->otyp, price / obj->quan, TRUE);</span>
  1686. <span id="line1682">1682. } else if (iflags.pricequotes && !objects[obj->otyp].oc_name_known) {</span>
  1687. <span id="line1683">1683. append_price_quote(bp, &bp_eos, obj->otyp);</span>
  1688. <span id="line1684">1684. }</span>
  1689. <span id="line1685">1685. </span>
  1690. <span id="line1686">1686. if (!strncmp(prefix, "a ", 2)) {</span>
  1691. <span id="line1687">1687. /* save current prefix, without "a "; might be empty */</span>
  1692. <span id="line1688">1688. Strcpy(tmpbuf, prefix + 2);</span>
  1693. <span id="line1689">1689. /* set prefix[] to "", "a ", or "an " */</span>
  1694. <span id="line1690">1690. (void) just_an(prefix, *tmpbuf ? tmpbuf : bp);</span>
  1695. <span id="line1691">1691. /* append remainder of original prefix */</span>
  1696. <span id="line1692">1692. Strcat(prefix, tmpbuf);</span>
  1697. <span id="line1693">1693. }</span>
  1698. <span id="line1694">1694. </span>
  1699. <span id="line1695">1695. /* show weight for items (debug tourist info);</span>
  1700. <span id="line1696">1696. "aum" is stolen from Crawl's "Arbitrary Unit of Measure" */</span>
  1701. <span id="line1697">1697. if (wizard && iflags.wizweight) {</span>
  1702. <span id="line1698">1698. /* wizard mode user has asked to see object weights */</span>
  1703. <span id="line1699">1699. if (with_price && bp_eos[-1] == ')')</span>
  1704. <span id="line1700">1700. ConcatF1(bp, 1, ", %u aum)", obj->owt);</span>
  1705. <span id="line1701">1701. else</span>
  1706. <span id="line1702">1702. ConcatF1(bp, 0, " (%u aum)", obj->owt);</span>
  1707. <span id="line1703">1703. </span>
  1708. <span id="line1704">1704. /* ConcatF1(bp) updates bp_eos and bpspaceleft but we're done</span>
  1709. <span id="line1705">1705. with them now; add a fake use so compiler won't complain</span>
  1710. <span id="line1706">1706. about a variable assignment that won't be subsequently used */</span>
  1711. <span id="line1707">1707. nhUse(bp_eos);</span>
  1712. <span id="line1708">1708. nhUse(bpspaceleft);</span>
  1713. <span id="line1709">1709. }</span>
  1714. <span id="line1710">1710. </span>
  1715. <span id="line1711">1711. bp = strprepend(bp, prefix);</span>
  1716. <span id="line1712">1712. </span>
  1717. <span id="line1713">1713. /*</span>
  1718. <span id="line1714">1714. * Last gasp bounds check.</span>
  1719. <span id="line1715">1715. *</span>
  1720. <span id="line1716">1716. * If caller intends this to be for a menu entry, make sure that</span>
  1721. <span id="line1717">1717. * there is some room to combine with menu selector prefix without</span>
  1722. <span id="line1718">1718. * exceeding BUFSZ-1.</span>
  1723. <span id="line1719">1719. *</span>
  1724. <span id="line1720">1720. * offsetbp=4: width of menu entry selector text: "c - " for tty.</span>
  1725. <span id="line1721">1721. * For curses, that wastes a char since it only needs 3: "c) ".</span>
  1726. <span id="line1722">1722. *</span>
  1727. <span id="line1723">1723. * Reaching full BUFSZ-1 length can't happen unless both doname</span>
  1728. <span id="line1724">1724. * (BUFSZ-PREFIX) and strprepend (PREFIX) use up all available</span>
  1729. <span id="line1725">1725. * space or one of them overflows without being detected.</span>
  1730. <span id="line1726">1726. */</span>
  1731. <span id="line1727">1727. if (strlen(bp) > BUFSZ - 1) {</span>
  1732. <span id="line1728">1728. paniclog("doname", bp);</span>
  1733. <span id="line1729">1729. /* ideally this will never happen; if xnamep is any obuf[]</span>
  1734. <span id="line1730">1730. other than the last, overflow here would be relatively</span>
  1735. <span id="line1731">1731. benign and we could probably keep going */</span>
  1736. <span id="line1732">1732. panic("doname: long object description overflow.");</span>
  1737. <span id="line1733">1733. /*NOTREACHED*/</span>
  1738. <span id="line1734">1734. } else {</span>
  1739. <span id="line1735">1735. static int doname_full = 0;</span>
  1740. <span id="line1736">1736. int offsetbp = for_menu ? 4 : 0;</span>
  1741. <span id="line1737">1737. </span>
  1742. <span id="line1738">1738. if (strlen(bp) + offsetbp >= BUFSZ - 1) {</span>
  1743. <span id="line1739">1739. /* for !offsetbp, we'll only get here if strlen(bp)==BUFSZ-1 */</span>
  1744. <span id="line1740">1740. if (!doname_full++) {</span>
  1745. <span id="line1741">1741. paniclog("doname", bp);</span>
  1746. <span id="line1742">1742. Sprintf(tmpbuf, "long object description%s.",</span>
  1747. <span id="line1743">1743. offsetbp ? " truncated for menu use" : "");</span>
  1748. <span id="line1744">1744. paniclog("doname", tmpbuf);</span>
  1749. <span id="line1745">1745. }</span>
  1750. <span id="line1746">1746. bp[BUFSZ - 1 - offsetbp] = '\0';</span>
  1751. <span id="line1747">1747. }</span>
  1752. <span id="line1748">1748. }</span>
  1753. <span id="line1749">1749. </span>
  1754. <span id="line1750">1750. return bp;</span>
  1755. <span id="line1751">1751. }</span>
  1756. <span id="line1752">1752. </span>
  1757. <span id="line1753">1753. char *</span>
  1758. <span id="line1754">1754. doname(struct obj *obj)</span>
  1759. <span id="line1755">1755. {</span>
  1760. <span id="line1756">1756. return doname_base(obj, (unsigned) 0);</span>
  1761. <span id="line1757">1757. }</span>
  1762. <span id="line1758">1758. </span>
  1763. <span id="line1759">1759. /* Name of object including price. */</span>
  1764. <span id="line1760">1760. char *</span>
  1765. <span id="line1761">1761. doname_with_price(struct obj *obj)</span>
  1766. <span id="line1762">1762. {</span>
  1767. <span id="line1763">1763. return doname_base(obj, DONAME_WITH_PRICE);</span>
  1768. <span id="line1764">1764. }</span>
  1769. <span id="line1765">1765. </span>
  1770. <span id="line1766">1766. /* "some" instead of precise quantity if obj->dknown not set */</span>
  1771. <span id="line1767">1767. char *</span>
  1772. <span id="line1768">1768. doname_vague_quan(struct obj *obj)</span>
  1773. <span id="line1769">1769. {</span>
  1774. <span id="line1770">1770. /* Used by farlook.</span>
  1775. <span id="line1771">1771. * If it hasn't been seen up close and quantity is more than one,</span>
  1776. <span id="line1772">1772. * use "some" instead of the quantity: "some gold pieces" rather</span>
  1777. <span id="line1773">1773. * than "25 gold pieces". This is suboptimal, to put it mildly,</span>
  1778. <span id="line1774">1774. * because lookhere and pickup report the precise amount.</span>
  1779. <span id="line1775">1775. * Picking the item up while blind also shows the precise amount</span>
  1780. <span id="line1776">1776. * for inventory display, then dropping it while still blind leaves</span>
  1781. <span id="line1777">1777. * obj->dknown unset so the count reverts to "some" for farlook.</span>
  1782. <span id="line1778">1778. *</span>
  1783. <span id="line1779">1779. * TODO: add obj->qknown flag for 'quantity known' on stackable</span>
  1784. <span id="line1780">1780. * items; it could overlay obj->cknown since no containers stack.</span>
  1785. <span id="line1781">1781. */</span>
  1786. <span id="line1782">1782. return doname_base(obj, DONAME_VAGUE_QUAN);</span>
  1787. <span id="line1783">1783. }</span>
  1788. <span id="line1784">1784. </span>
  1789. <span id="line1785">1785. /* used from invent.c */</span>
  1790. <span id="line1786">1786. boolean</span>
  1791. <span id="line1787">1787. not_fully_identified(struct obj *otmp)</span>
  1792. <span id="line1788">1788. {</span>
  1793. <span id="line1789">1789. /* gold doesn't have any interesting attributes [yet?] */</span>
  1794. <span id="line1790">1790. if (otmp->oclass == COIN_CLASS)</span>
  1795. <span id="line1791">1791. return FALSE; /* always fully ID'd */</span>
  1796. <span id="line1792">1792. /* check fundamental ID hallmarks first */</span>
  1797. <span id="line1793">1793. if (!otmp->known || !otmp->dknown</span>
  1798. <span id="line1794">1794. #ifdef MAIL_STRUCTURES</span>
  1799. <span id="line1795">1795. || (!otmp->bknown && otmp->otyp != SCR_MAIL)</span>
  1800. <span id="line1796">1796. #else</span>
  1801. <span id="line1797">1797. || !otmp->bknown</span>
  1802. <span id="line1798">1798. #endif</span>
  1803. <span id="line1799">1799. || !objects[otmp->otyp].oc_name_known)</span>
  1804. <span id="line1800">1800. return TRUE;</span>
  1805. <span id="line1801">1801. if ((!otmp->cknown && (Is_container(otmp) || otmp->otyp == STATUE))</span>
  1806. <span id="line1802">1802. || (!otmp->lknown && Is_box(otmp)))</span>
  1807. <span id="line1803">1803. return TRUE;</span>
  1808. <span id="line1804">1804. if (otmp->oartifact && undiscovered_artifact(otmp->oartifact))</span>
  1809. <span id="line1805">1805. return TRUE;</span>
  1810. <span id="line1806">1806. /* otmp->rknown is the only item of interest if we reach here */</span>
  1811. <span id="line1807">1807. /*</span>
  1812. <span id="line1808">1808. * Note: if a revision ever allows scrolls to become fireproof or</span>
  1813. <span id="line1809">1809. * rings to become shockproof, this checking will need to be revised.</span>
  1814. <span id="line1810">1810. * `rknown' ID only matters if xname() will provide the info about it.</span>
  1815. <span id="line1811">1811. */</span>
  1816. <span id="line1812">1812. if (otmp->rknown</span>
  1817. <span id="line1813">1813. || (otmp->oclass != ARMOR_CLASS && otmp->oclass != WEAPON_CLASS</span>
  1818. <span id="line1814">1814. && !is_weptool(otmp) /* (redundant) */</span>
  1819. <span id="line1815">1815. && otmp->oclass != BALL_CLASS)) /* (useless) */</span>
  1820. <span id="line1816">1816. return FALSE;</span>
  1821. <span id="line1817">1817. else /* lack of `rknown' only matters for vulnerable objects */</span>
  1822. <span id="line1818">1818. return (boolean) is_damageable(otmp);</span>
  1823. <span id="line1819">1819. }</span>
  1824. <span id="line1820">1820. </span>
  1825. <span id="line1821">1821. /* format a corpse name (xname() omits monster type; doname() calls us);</span>
  1826. <span id="line1822">1822. eatcorpse() also uses us for death reason when eating tainted glob */</span>
  1827. <span id="line1823">1823. char *</span>
  1828. <span id="line1824">1824. corpse_xname(</span>
  1829. <span id="line1825">1825. struct obj *otmp,</span>
  1830. <span id="line1826">1826. const char *adjective,</span>
  1831. <span id="line1827">1827. unsigned cxn_flags) /* bitmask of CXN_xxx values */</span>
  1832. <span id="line1828">1828. {</span>
  1833. <span id="line1829">1829. char *nambuf;</span>
  1834. <span id="line1830">1830. int omndx = otmp->corpsenm;</span>
  1835. <span id="line1831">1831. boolean ignore_quan = (cxn_flags & CXN_SINGULAR) != 0,</span>
  1836. <span id="line1832">1832. /* suppress "the" from "the unique monster corpse" */</span>
  1837. <span id="line1833">1833. no_prefix = (cxn_flags & CXN_NO_PFX) != 0,</span>
  1838. <span id="line1834">1834. /* include "the" for "the woodchuck corpse */</span>
  1839. <span id="line1835">1835. the_prefix = (cxn_flags & CXN_PFX_THE) != 0,</span>
  1840. <span id="line1836">1836. /* include "an" for "an ogre corpse */</span>
  1841. <span id="line1837">1837. any_prefix = (cxn_flags & CXN_ARTICLE) != 0,</span>
  1842. <span id="line1838">1838. /* leave off suffix (do_name() appends "corpse" itself) */</span>
  1843. <span id="line1839">1839. omit_corpse = (cxn_flags & CXN_NOCORPSE) != 0,</span>
  1844. <span id="line1840">1840. possessive = FALSE,</span>
  1845. <span id="line1841">1841. glob = (otmp->otyp != CORPSE && otmp->globby);</span>
  1846. <span id="line1842">1842. const char *mnam;</span>
  1847. <span id="line1843">1843. </span>
  1848. <span id="line1844">1844. /* some callers [aobjnam()] rely on prefix area that xname() sets aside */</span>
  1849. <span id="line1845">1845. gx.xnamep = nextobuf();</span>
  1850. <span id="line1846">1846. nambuf = gx.xnamep + PREFIX;</span>
  1851. <span id="line1847">1847. </span>
  1852. <span id="line1848">1848. if (glob) {</span>
  1853. <span id="line1849">1849. mnam = OBJ_NAME(objects[otmp->otyp]); /* "glob of <monster>" */</span>
  1854. <span id="line1850">1850. } else if (omndx == NON_PM) { /* paranoia */</span>
  1855. <span id="line1851">1851. mnam = "thing";</span>
  1856. <span id="line1852">1852. } else {</span>
  1857. <span id="line1853">1853. mnam = obj_pmname(otmp);</span>
  1858. <span id="line1854">1854. if (the_unique_pm(&mons[omndx]) || type_is_pname(&mons[omndx])) {</span>
  1859. <span id="line1855">1855. mnam = s_suffix(mnam);</span>
  1860. <span id="line1856">1856. possessive = TRUE;</span>
  1861. <span id="line1857">1857. /* don't precede personal name like "Medusa" with an article */</span>
  1862. <span id="line1858">1858. if (type_is_pname(&mons[omndx]))</span>
  1863. <span id="line1859">1859. no_prefix = TRUE;</span>
  1864. <span id="line1860">1860. /* always precede non-personal unique monster name like</span>
  1865. <span id="line1861">1861. "Oracle" with "the" unless explicitly overridden */</span>
  1866. <span id="line1862">1862. else if (the_unique_pm(&mons[omndx]) && !no_prefix)</span>
  1867. <span id="line1863">1863. the_prefix = TRUE;</span>
  1868. <span id="line1864">1864. }</span>
  1869. <span id="line1865">1865. }</span>
  1870. <span id="line1866">1866. if (no_prefix)</span>
  1871. <span id="line1867">1867. the_prefix = any_prefix = FALSE;</span>
  1872. <span id="line1868">1868. else if (the_prefix)</span>
  1873. <span id="line1869">1869. any_prefix = FALSE; /* mutually exclusive */</span>
  1874. <span id="line1870">1870. </span>
  1875. <span id="line1871">1871. *nambuf = '\0';</span>
  1876. <span id="line1872">1872. /* can't use the() the way we use an() below because any capitalized</span>
  1877. <span id="line1873">1873. Name causes it to assume a personal name and return Name as-is;</span>
  1878. <span id="line1874">1874. that's usually the behavior wanted, but here we need to force "the"</span>
  1879. <span id="line1875">1875. to precede capitalized unique monsters (pnames are handled above) */</span>
  1880. <span id="line1876">1876. if (the_prefix)</span>
  1881. <span id="line1877">1877. Strcat(nambuf, "the ");</span>
  1882. <span id="line1878">1878. /* note: over time, various instances of the(mon_name()) have crept</span>
  1883. <span id="line1879">1879. into the code, so the() has been modified to deal with capitalized</span>
  1884. <span id="line1880">1880. monster names; we could switch to using it below like an() */</span>
  1885. <span id="line1881">1881. </span>
  1886. <span id="line1882">1882. if (!adjective || !*adjective) {</span>
  1887. <span id="line1883">1883. /* normal case: newt corpse */</span>
  1888. <span id="line1884">1884. Strcat(nambuf, mnam);</span>
  1889. <span id="line1885">1885. } else {</span>
  1890. <span id="line1886">1886. /* adjective positioning depends upon format of monster name */</span>
  1891. <span id="line1887">1887. if (possessive) /* Medusa's cursed partly eaten corpse */</span>
  1892. <span id="line1888">1888. Sprintf(eos(nambuf), "%s %s", mnam, adjective);</span>
  1893. <span id="line1889">1889. else /* cursed partly eaten troll corpse */</span>
  1894. <span id="line1890">1890. Sprintf(eos(nambuf), "%s %s", adjective, mnam);</span>
  1895. <span id="line1891">1891. /* in case adjective has a trailing space, squeeze it out */</span>
  1896. <span id="line1892">1892. mungspaces(nambuf);</span>
  1897. <span id="line1893">1893. /* doname() might include a count in the adjective argument;</span>
  1898. <span id="line1894">1894. if so, don't prepend an article */</span>
  1899. <span id="line1895">1895. if (digit(*adjective))</span>
  1900. <span id="line1896">1896. any_prefix = FALSE;</span>
  1901. <span id="line1897">1897. }</span>
  1902. <span id="line1898">1898. </span>
  1903. <span id="line1899">1899. if (glob) {</span>
  1904. <span id="line1900">1900. ; /* omit_corpse doesn't apply; quantity is always 1 */</span>
  1905. <span id="line1901">1901. } else if (!omit_corpse) {</span>
  1906. <span id="line1902">1902. Strcat(nambuf, " corpse");</span>
  1907. <span id="line1903">1903. /* makeplural(nambuf) => append "s" to "corpse" */</span>
  1908. <span id="line1904">1904. if (otmp->quan > 1L && !ignore_quan) {</span>
  1909. <span id="line1905">1905. Strcat(nambuf, "s");</span>
  1910. <span id="line1906">1906. any_prefix = FALSE; /* avoid "a newt corpses" */</span>
  1911. <span id="line1907">1907. }</span>
  1912. <span id="line1908">1908. }</span>
  1913. <span id="line1909">1909. </span>
  1914. <span id="line1910">1910. /* it's safe to overwrite our nambuf[] after an() has copied its</span>
  1915. <span id="line1911">1911. old value into another buffer; and once _that_ has been copied,</span>
  1916. <span id="line1912">1912. the obuf[] returned by an() can be made available for re-use */</span>
  1917. <span id="line1913">1913. if (any_prefix) {</span>
  1918. <span id="line1914">1914. char *obufp;</span>
  1919. <span id="line1915">1915. </span>
  1920. <span id="line1916">1916. Strcpy(nambuf, obufp = an(nambuf));</span>
  1921. <span id="line1917">1917. releaseobuf(obufp);</span>
  1922. <span id="line1918">1918. }</span>
  1923. <span id="line1919">1919. return nambuf;</span>
  1924. <span id="line1920">1920. }</span>
  1925. <span id="line1921">1921. </span>
  1926. <span id="line1922">1922. /* xname doesn't include monster type for "corpse"; cxname does */</span>
  1927. <span id="line1923">1923. char *</span>
  1928. <span id="line1924">1924. cxname(struct obj *obj)</span>
  1929. <span id="line1925">1925. {</span>
  1930. <span id="line1926">1926. if (obj->otyp == CORPSE)</span>
  1931. <span id="line1927">1927. return corpse_xname(obj, (const char *) 0, CXN_NORMAL);</span>
  1932. <span id="line1928">1928. return xname(obj);</span>
  1933. <span id="line1929">1929. }</span>
  1934. <span id="line1930">1930. </span>
  1935. <span id="line1931">1931. /* like cxname, but ignores quantity */</span>
  1936. <span id="line1932">1932. char *</span>
  1937. <span id="line1933">1933. cxname_singular(struct obj *obj)</span>
  1938. <span id="line1934">1934. {</span>
  1939. <span id="line1935">1935. if (obj->otyp == CORPSE)</span>
  1940. <span id="line1936">1936. return corpse_xname(obj, (const char *) 0, CXN_SINGULAR);</span>
  1941. <span id="line1937">1937. return xname_flags(obj, CXN_SINGULAR);</span>
  1942. <span id="line1938">1938. }</span>
  1943. <span id="line1939">1939. </span>
  1944. <span id="line1940">1940. /* treat an object as fully ID'd when it might be used as reason for death */</span>
  1945. <span id="line1941">1941. char *</span>
  1946. <span id="line1942">1942. killer_xname(struct obj *obj)</span>
  1947. <span id="line1943">1943. {</span>
  1948. <span id="line1944">1944. struct obj save_obj;</span>
  1949. <span id="line1945">1945. unsigned save_ocknown;</span>
  1950. <span id="line1946">1946. char *buf, *save_ocuname, *save_oname = (char *) 0;</span>
  1951. <span id="line1947">1947. </span>
  1952. <span id="line1948">1948. /* bypass object twiddling for artifacts */</span>
  1953. <span id="line1949">1949. if (obj->oartifact)</span>
  1954. <span id="line1950">1950. return bare_artifactname(obj);</span>
  1955. <span id="line1951">1951. </span>
  1956. <span id="line1952">1952. /* remember original settings for core of the object;</span>
  1957. <span id="line1953">1953. oextra structs other than oname don't matter here--since they</span>
  1958. <span id="line1954">1954. aren't modified they don't need to be saved and restored */</span>
  1959. <span id="line1955">1955. save_obj = *obj;</span>
  1960. <span id="line1956">1956. if (has_oname(obj))</span>
  1961. <span id="line1957">1957. save_oname = ONAME(obj);</span>
  1962. <span id="line1958">1958. </span>
  1963. <span id="line1959">1959. /* killer name should be more specific than general xname; however, exact</span>
  1964. <span id="line1960">1960. info like blessed/cursed and rustproof makes things be too verbose; set</span>
  1965. <span id="line1961">1961. dknown (not observe_object) because dead characters don't observe */</span>
  1966. <span id="line1962">1962. obj->known = obj->dknown = 1;</span>
  1967. <span id="line1963">1963. obj->bknown = obj->rknown = obj->greased = 0;</span>
  1968. <span id="line1964">1964. /* if character is a priest[ess], bknown will get toggled back on */</span>
  1969. <span id="line1965">1965. if (obj->otyp != POT_WATER)</span>
  1970. <span id="line1966">1966. obj->blessed = obj->cursed = 0;</span>
  1971. <span id="line1967">1967. else</span>
  1972. <span id="line1968">1968. obj->bknown = 1; /* describe holy/unholy water as such */</span>
  1973. <span id="line1969">1969. /* "killed by poisoned <obj>" would be misleading when poison is</span>
  1974. <span id="line1970">1970. not the cause of death and "poisoned by poisoned <obj>" would</span>
  1975. <span id="line1971">1971. be redundant when it is, so suppress "poisoned" prefix */</span>
  1976. <span id="line1972">1972. obj->opoisoned = 0;</span>
  1977. <span id="line1973">1973. /* strip user-supplied name; artifacts keep theirs */</span>
  1978. <span id="line1974">1974. if (!obj->oartifact && save_oname)</span>
  1979. <span id="line1975">1975. ONAME(obj) = (char *) 0;</span>
  1980. <span id="line1976">1976. /* temporarily identify the type of object */</span>
  1981. <span id="line1977">1977. save_ocknown = objects[obj->otyp].oc_name_known;</span>
  1982. <span id="line1978">1978. objects[obj->otyp].oc_name_known = 1;</span>
  1983. <span id="line1979">1979. save_ocuname = objects[obj->otyp].oc_uname;</span>
  1984. <span id="line1980">1980. objects[obj->otyp].oc_uname = 0; /* avoid "foo called bar" */</span>
  1985. <span id="line1981">1981. </span>
  1986. <span id="line1982">1982. /* format the object */</span>
  1987. <span id="line1983">1983. if (obj->otyp == CORPSE) {</span>
  1988. <span id="line1984">1984. buf = corpse_xname(obj, (const char *) 0, CXN_NORMAL);</span>
  1989. <span id="line1985">1985. } else if (obj->otyp == SLIME_MOLD) {</span>
  1990. <span id="line1986">1986. /* concession to "most unique deaths competition" in the annual</span>
  1991. <span id="line1987">1987. devnull tournament, suppress player supplied fruit names because</span>
  1992. <span id="line1988">1988. those can be used to fake other objects and dungeon features */</span>
  1993. <span id="line1989">1989. buf = nextobuf();</span>
  1994. <span id="line1990">1990. Sprintf(buf, "deadly slime mold%s", plur(obj->quan));</span>
  1995. <span id="line1991">1991. } else {</span>
  1996. <span id="line1992">1992. buf = xname(obj);</span>
  1997. <span id="line1993">1993. }</span>
  1998. <span id="line1994">1994. /* apply an article if appropriate; caller should always use KILLED_BY */</span>
  1999. <span id="line1995">1995. if (obj->quan == 1L && !strstri(buf, "'s ") && !strstri(buf, "s' "))</span>
  2000. <span id="line1996">1996. buf = (obj_is_pname(obj) || the_unique_obj(obj)) ? the(buf) : an(buf);</span>
  2001. <span id="line1997">1997. </span>
  2002. <span id="line1998">1998. objects[obj->otyp].oc_name_known = save_ocknown;</span>
  2003. <span id="line1999">1999. objects[obj->otyp].oc_uname = save_ocuname;</span>
  2004. <span id="line2000">2000. *obj = save_obj; /* restore object's core settings */</span>
  2005. <span id="line2001">2001. if (!obj->oartifact && save_oname)</span>
  2006. <span id="line2002">2002. ONAME(obj) = save_oname;</span>
  2007. <span id="line2003">2003. </span>
  2008. <span id="line2004">2004. return buf;</span>
  2009. <span id="line2005">2005. }</span>
  2010. <span id="line2006">2006. </span>
  2011. <span id="line2007">2007. /* xname,doname,&c with long results reformatted to omit some stuff */</span>
  2012. <span id="line2008">2008. char *</span>
  2013. <span id="line2009">2009. short_oname(</span>
  2014. <span id="line2010">2010. struct obj *obj,</span>
  2015. <span id="line2011">2011. char *(*func)(OBJ_P), /* main formatting routine */</span>
  2016. <span id="line2012">2012. char *(*altfunc)(OBJ_P), /* alternate for shortest result */</span>
  2017. <span id="line2013">2013. unsigned lenlimit)</span>
  2018. <span id="line2014">2014. {</span>
  2019. <span id="line2015">2015. struct obj save_obj;</span>
  2020. <span id="line2016">2016. char unamebuf[12], onamebuf[12], *save_oname, *save_uname, *outbuf;</span>
  2021. <span id="line2017">2017. </span>
  2022. <span id="line2018">2018. outbuf = (*func)(obj);</span>
  2023. <span id="line2019">2019. if ((unsigned) strlen(outbuf) <= lenlimit)</span>
  2024. <span id="line2020">2020. return outbuf;</span>
  2025. <span id="line2021">2021. </span>
  2026. <span id="line2022">2022. /* shorten called string to fairly small amount */</span>
  2027. <span id="line2023">2023. save_uname = objects[obj->otyp].oc_uname;</span>
  2028. <span id="line2024">2024. if (save_uname && strlen(save_uname) >= sizeof unamebuf) {</span>
  2029. <span id="line2025">2025. (void) strncpy(unamebuf, save_uname, sizeof unamebuf - 4);</span>
  2030. <span id="line2026">2026. Strcpy(unamebuf + sizeof unamebuf - 4, "...");</span>
  2031. <span id="line2027">2027. objects[obj->otyp].oc_uname = unamebuf;</span>
  2032. <span id="line2028">2028. releaseobuf(outbuf);</span>
  2033. <span id="line2029">2029. outbuf = (*func)(obj);</span>
  2034. <span id="line2030">2030. objects[obj->otyp].oc_uname = save_uname; /* restore called string */</span>
  2035. <span id="line2031">2031. if ((unsigned) strlen(outbuf) <= lenlimit)</span>
  2036. <span id="line2032">2032. return outbuf;</span>
  2037. <span id="line2033">2033. }</span>
  2038. <span id="line2034">2034. </span>
  2039. <span id="line2035">2035. /* shorten named string to fairly small amount */</span>
  2040. <span id="line2036">2036. save_oname = has_oname(obj) ? ONAME(obj) : 0;</span>
  2041. <span id="line2037">2037. if (save_oname && strlen(save_oname) >= sizeof onamebuf) {</span>
  2042. <span id="line2038">2038. (void) strncpy(onamebuf, save_oname, sizeof onamebuf - 4);</span>
  2043. <span id="line2039">2039. Strcpy(onamebuf + sizeof onamebuf - 4, "...");</span>
  2044. <span id="line2040">2040. ONAME(obj) = onamebuf;</span>
  2045. <span id="line2041">2041. releaseobuf(outbuf);</span>
  2046. <span id="line2042">2042. outbuf = (*func)(obj);</span>
  2047. <span id="line2043">2043. ONAME(obj) = save_oname; /* restore named string */</span>
  2048. <span id="line2044">2044. if ((unsigned) strlen(outbuf) <= lenlimit)</span>
  2049. <span id="line2045">2045. return outbuf;</span>
  2050. <span id="line2046">2046. }</span>
  2051. <span id="line2047">2047. </span>
  2052. <span id="line2048">2048. /* shorten both called and named strings;</span>
  2053. <span id="line2049">2049. unamebuf and onamebuf have both already been populated */</span>
  2054. <span id="line2050">2050. if (save_uname && strlen(save_uname) >= sizeof unamebuf && save_oname</span>
  2055. <span id="line2051">2051. && strlen(save_oname) >= sizeof onamebuf) {</span>
  2056. <span id="line2052">2052. objects[obj->otyp].oc_uname = unamebuf;</span>
  2057. <span id="line2053">2053. ONAME(obj) = onamebuf;</span>
  2058. <span id="line2054">2054. releaseobuf(outbuf);</span>
  2059. <span id="line2055">2055. outbuf = (*func)(obj);</span>
  2060. <span id="line2056">2056. if ((unsigned) strlen(outbuf) <= lenlimit) {</span>
  2061. <span id="line2057">2057. objects[obj->otyp].oc_uname = save_uname;</span>
  2062. <span id="line2058">2058. ONAME(obj) = save_oname;</span>
  2063. <span id="line2059">2059. return outbuf;</span>
  2064. <span id="line2060">2060. }</span>
  2065. <span id="line2061">2061. }</span>
  2066. <span id="line2062">2062. </span>
  2067. <span id="line2063">2063. /* still long; strip several name-lengthening attributes;</span>
  2068. <span id="line2064">2064. called and named strings are still in truncated form */</span>
  2069. <span id="line2065">2065. save_obj = *obj;</span>
  2070. <span id="line2066">2066. obj->bknown = obj->rknown = obj->greased = 0;</span>
  2071. <span id="line2067">2067. obj->oeroded = obj->oeroded2 = 0;</span>
  2072. <span id="line2068">2068. releaseobuf(outbuf);</span>
  2073. <span id="line2069">2069. outbuf = (*func)(obj);</span>
  2074. <span id="line2070">2070. if (altfunc && (unsigned) strlen(outbuf) > lenlimit) {</span>
  2075. <span id="line2071">2071. /* still long; use the alternate function (usually one of</span>
  2076. <span id="line2072">2072. the jackets around minimal_xname()) */</span>
  2077. <span id="line2073">2073. releaseobuf(outbuf);</span>
  2078. <span id="line2074">2074. outbuf = (*altfunc)(obj);</span>
  2079. <span id="line2075">2075. }</span>
  2080. <span id="line2076">2076. /* restore the object */</span>
  2081. <span id="line2077">2077. *obj = save_obj;</span>
  2082. <span id="line2078">2078. if (save_oname)</span>
  2083. <span id="line2079">2079. ONAME(obj) = save_oname;</span>
  2084. <span id="line2080">2080. if (save_uname)</span>
  2085. <span id="line2081">2081. objects[obj->otyp].oc_uname = save_uname;</span>
  2086. <span id="line2082">2082. </span>
  2087. <span id="line2083">2083. /* use whatever we've got, whether it's too long or not */</span>
  2088. <span id="line2084">2084. return outbuf;</span>
  2089. <span id="line2085">2085. }</span>
  2090. <span id="line2086">2086. </span>
  2091. <span id="line2087">2087. /*</span>
  2092. <span id="line2088">2088. * Used if only one of a collection of objects is named (e.g. in eat.c).</span>
  2093. <span id="line2089">2089. */</span>
  2094. <span id="line2090">2090. const char *</span>
  2095. <span id="line2091">2091. singular(struct obj *otmp, char *(*func)(OBJ_P))</span>
  2096. <span id="line2092">2092. {</span>
  2097. <span id="line2093">2093. long savequan;</span>
  2098. <span id="line2094">2094. char *nam;</span>
  2099. <span id="line2095">2095. </span>
  2100. <span id="line2096">2096. /* using xname for corpses does not give the monster type */</span>
  2101. <span id="line2097">2097. if (otmp->otyp == CORPSE && func == xname)</span>
  2102. <span id="line2098">2098. func = cxname;</span>
  2103. <span id="line2099">2099. </span>
  2104. <span id="line2100">2100. savequan = otmp->quan;</span>
  2105. <span id="line2101">2101. otmp->quan = 1L;</span>
  2106. <span id="line2102">2102. nam = (*func)(otmp);</span>
  2107. <span id="line2103">2103. otmp->quan = savequan;</span>
  2108. <span id="line2104">2104. return nam;</span>
  2109. <span id="line2105">2105. }</span>
  2110. <span id="line2106">2106. </span>
  2111. <span id="line2107">2107. /* pick "", "a ", or "an " as article for 'str'; used by an() and doname() */</span>
  2112. <span id="line2108">2108. char *</span>
  2113. <span id="line2109">2109. just_an(char *outbuf, const char *str)</span>
  2114. <span id="line2110">2110. {</span>
  2115. <span id="line2111">2111. char c0;</span>
  2116. <span id="line2112">2112. </span>
  2117. <span id="line2113">2113. *outbuf = '\0';</span>
  2118. <span id="line2114">2114. c0 = lowc(*str);</span>
  2119. <span id="line2115">2115. if (!str[1] || str[1] == ' ') {</span>
  2120. <span id="line2116">2116. /* single letter; might be used for named fruit or a musical note */</span>
  2121. <span id="line2117">2117. Strcpy(outbuf, strchr("aefhilmnosx", c0) ? "an " : "a ");</span>
  2122. <span id="line2118">2118. } else if (!strncmpi(str, "the ", 4)</span>
  2123. <span id="line2119">2119. /* these probably shouldn't be handled here because doing so</span>
  2124. <span id="line2120">2120. impacts inventory when using them for named fruit */</span>
  2125. <span id="line2121">2121. || !strcmpi(str, "molten lava")</span>
  2126. <span id="line2122">2122. || !strcmpi(str, "iron bars")</span>
  2127. <span id="line2123">2123. || !strcmpi(str, "ice")</span>
  2128. <span id="line2124">2124. ) {</span>
  2129. <span id="line2125">2125. ; /* no article */</span>
  2130. <span id="line2126">2126. } else {</span>
  2131. <span id="line2127">2127. /* normal case is "an <vowel>" or "a <consonant>" */</span>
  2132. <span id="line2128">2128. if ((strchr(vowels, c0) /* some exceptions warranting "a <vowel>" */</span>
  2133. <span id="line2129">2129. /* 'wun' initial sound */</span>
  2134. <span id="line2130">2130. && (strncmpi(str, "one", 3) || (str[3] && !strchr("-_ ", str[3])))</span>
  2135. <span id="line2131">2131. /* long 'u' initial sound */</span>
  2136. <span id="line2132">2132. && strncmpi(str, "eu", 2) /* "eucalyptus leaf" */</span>
  2137. <span id="line2133">2133. && strncmpi(str, "uke", 3) && strncmpi(str, "ukulele", 7)</span>
  2138. <span id="line2134">2134. && strncmpi(str, "unicorn", 7) && strncmpi(str, "uranium", 7)</span>
  2139. <span id="line2135">2135. && strncmpi(str, "useful", 6)) /* "useful tool" */</span>
  2140. <span id="line2136">2136. || (c0 == 'x' && !strchr(vowels, lowc(str[1]))))</span>
  2141. <span id="line2137">2137. Strcpy(outbuf, "an ");</span>
  2142. <span id="line2138">2138. else</span>
  2143. <span id="line2139">2139. Strcpy(outbuf, "a ");</span>
  2144. <span id="line2140">2140. }</span>
  2145. <span id="line2141">2141. return outbuf;</span>
  2146. <span id="line2142">2142. }</span>
  2147. <span id="line2143">2143. </span>
  2148. <span id="line2144">2144. char *</span>
  2149. <span id="line2145">2145. an(const char *str)</span>
  2150. <span id="line2146">2146. {</span>
  2151. <span id="line2147">2147. char *buf = nextobuf();</span>
  2152. <span id="line2148">2148. </span>
  2153. <span id="line2149">2149. if (!str || !*str) {</span>
  2154. <span id="line2150">2150. impossible("Alphabet soup: 'an(%s)'.", str ? "\"\"" : "<null>");</span>
  2155. <span id="line2151">2151. return strcpy(buf, "an []");</span>
  2156. <span id="line2152">2152. }</span>
  2157. <span id="line2153">2153. (void) just_an(buf, str);</span>
  2158. <span id="line2154">2154. return strncat(buf, str, BUFSZ - 1 - Strlen(buf));</span>
  2159. <span id="line2155">2155. }</span>
  2160. <span id="line2156">2156. </span>
  2161. <span id="line2157">2157. char *</span>
  2162. <span id="line2158">2158. An(const char *str)</span>
  2163. <span id="line2159">2159. {</span>
  2164. <span id="line2160">2160. char *tmp = an(str);</span>
  2165. <span id="line2161">2161. </span>
  2166. <span id="line2162">2162. *tmp = highc(*tmp);</span>
  2167. <span id="line2163">2163. return tmp;</span>
  2168. <span id="line2164">2164. }</span>
  2169. <span id="line2165">2165. </span>
  2170. <span id="line2166">2166. /*</span>
  2171. <span id="line2167">2167. * Prepend "the" if necessary; assumes str is a subject derived from xname.</span>
  2172. <span id="line2168">2168. * Use type_is_pname() for monster names, not the(). the() is idempotent.</span>
  2173. <span id="line2169">2169. */</span>
  2174. <span id="line2170">2170. char *</span>
  2175. <span id="line2171">2171. the(const char *str)</span>
  2176. <span id="line2172">2172. {</span>
  2177. <span id="line2173">2173. const char *aname;</span>
  2178. <span id="line2174">2174. char *buf = nextobuf();</span>
  2179. <span id="line2175">2175. boolean insert_the = FALSE;</span>
  2180. <span id="line2176">2176. </span>
  2181. <span id="line2177">2177. if (!str || !*str) {</span>
  2182. <span id="line2178">2178. impossible("Alphabet soup: 'the(%s)'.", str ? "\"\"" : "<null>");</span>
  2183. <span id="line2179">2179. return strcpy(buf, "the []");</span>
  2184. <span id="line2180">2180. }</span>
  2185. <span id="line2181">2181. if (!strncmpi(str, "the ", 4)) {</span>
  2186. <span id="line2182">2182. buf[0] = lowc(*str);</span>
  2187. <span id="line2183">2183. Strcpy(&buf[1], str + 1);</span>
  2188. <span id="line2184">2184. return buf;</span>
  2189. <span id="line2185">2185. } else if (*str < 'A' || *str > 'Z'</span>
  2190. <span id="line2186">2186. /* some capitalized monster names want "the", others don't */</span>
  2191. <span id="line2187">2187. || CapitalMon(str)</span>
  2192. <span id="line2188">2188. /* treat named fruit as not a proper name, even if player</span>
  2193. <span id="line2189">2189. has assigned a capitalized proper name as his/her fruit,</span>
  2194. <span id="line2190">2190. unless it matches an artifact name */</span>
  2195. <span id="line2191">2191. || (fruit_from_name(str, TRUE, (int *) 0)</span>
  2196. <span id="line2192">2192. && ((aname = artifact_name(str, (short *) 0, FALSE)) == 0</span>
  2197. <span id="line2193">2193. || strncmpi(aname, "the ", 4) == 0))) {</span>
  2198. <span id="line2194">2194. /* not a proper name, needs an article */</span>
  2199. <span id="line2195">2195. insert_the = TRUE;</span>
  2200. <span id="line2196">2196. } else {</span>
  2201. <span id="line2197">2197. /* Probably a proper name, might not need an article */</span>
  2202. <span id="line2198">2198. char *named, *called;</span>
  2203. <span id="line2199">2199. const char *tmp;</span>
  2204. <span id="line2200">2200. int l;</span>
  2205. <span id="line2201">2201. </span>
  2206. <span id="line2202">2202. /* some objects have capitalized adjectives in their names */</span>
  2207. <span id="line2203">2203. if (((tmp = strrchr(str, ' ')) != 0 || (tmp = strrchr(str, '-')) != 0)</span>
  2208. <span id="line2204">2204. && (tmp[1] < 'A' || tmp[1] > 'Z')) {</span>
  2209. <span id="line2205">2205. /* insert "the" unless we have an apostrophe (where we assume</span>
  2210. <span id="line2206">2206. we're dealing with "Unique's corpse" when "Unique" wasn't</span>
  2211. <span id="line2207">2207. caught by CapitalMon() above) */</span>
  2212. <span id="line2208">2208. insert_the = !strchr(str, '\'');</span>
  2213. <span id="line2209">2209. } else if (tmp && strchr(str, ' ') < tmp) { /* has spaces */</span>
  2214. <span id="line2210">2210. /* it needs an article if the name contains "of" */</span>
  2215. <span id="line2211">2211. tmp = strstri(str, " of ");</span>
  2216. <span id="line2212">2212. named = strstri(str, " named ");</span>
  2217. <span id="line2213">2213. called = strstri(str, " called ");</span>
  2218. <span id="line2214">2214. if (called && (!named || called < named))</span>
  2219. <span id="line2215">2215. named = called;</span>
  2220. <span id="line2216">2216. </span>
  2221. <span id="line2217">2217. if (tmp && (!named || tmp < named)) /* found an "of" */</span>
  2222. <span id="line2218">2218. insert_the = TRUE;</span>
  2223. <span id="line2219">2219. /* stupid special case: lacks "of" but needs "the" */</span>
  2224. <span id="line2220">2220. else if (!named && (l = Strlen(str)) >= 31</span>
  2225. <span id="line2221">2221. && !strcmp(&str[l - 31],</span>
  2226. <span id="line2222">2222. "Platinum Yendorian Express Card"))</span>
  2227. <span id="line2223">2223. insert_the = TRUE;</span>
  2228. <span id="line2224">2224. }</span>
  2229. <span id="line2225">2225. }</span>
  2230. <span id="line2226">2226. if (insert_the)</span>
  2231. <span id="line2227">2227. Strcpy(buf, "the ");</span>
  2232. <span id="line2228">2228. else</span>
  2233. <span id="line2229">2229. buf[0] = '\0';</span>
  2234. <span id="line2230">2230. return strncat(buf, str, BUFSZ - 1 - Strlen(buf));</span>
  2235. <span id="line2231">2231. }</span>
  2236. <span id="line2232">2232. </span>
  2237. <span id="line2233">2233. char *</span>
  2238. <span id="line2234">2234. The(const char *str)</span>
  2239. <span id="line2235">2235. {</span>
  2240. <span id="line2236">2236. char *tmp = the(str);</span>
  2241. <span id="line2237">2237. </span>
  2242. <span id="line2238">2238. *tmp = highc(*tmp);</span>
  2243. <span id="line2239">2239. return tmp;</span>
  2244. <span id="line2240">2240. }</span>
  2245. <span id="line2241">2241. </span>
  2246. <span id="line2242">2242. /* returns "count cxname(otmp)" or just cxname(otmp) if count == 1 */</span>
  2247. <span id="line2243">2243. char *</span>
  2248. <span id="line2244">2244. aobjnam(struct obj *otmp, const char *verb)</span>
  2249. <span id="line2245">2245. {</span>
  2250. <span id="line2246">2246. char prefix[PREFIX];</span>
  2251. <span id="line2247">2247. char *bp = cxname(otmp);</span>
  2252. <span id="line2248">2248. </span>
  2253. <span id="line2249">2249. if (otmp->quan != 1L) {</span>
  2254. <span id="line2250">2250. Sprintf(prefix, "%ld ", otmp->quan);</span>
  2255. <span id="line2251">2251. bp = strprepend(bp, prefix);</span>
  2256. <span id="line2252">2252. }</span>
  2257. <span id="line2253">2253. if (verb) {</span>
  2258. <span id="line2254">2254. Strcat(bp, " ");</span>
  2259. <span id="line2255">2255. Strcat(bp, otense(otmp, verb));</span>
  2260. <span id="line2256">2256. }</span>
  2261. <span id="line2257">2257. return bp;</span>
  2262. <span id="line2258">2258. }</span>
  2263. <span id="line2259">2259. </span>
  2264. <span id="line2260">2260. /* combine yname and aobjnam eg "your count cxname(otmp)" */</span>
  2265. <span id="line2261">2261. char *</span>
  2266. <span id="line2262">2262. yobjnam(struct obj *obj, const char *verb)</span>
  2267. <span id="line2263">2263. {</span>
  2268. <span id="line2264">2264. char *s = aobjnam(obj, verb);</span>
  2269. <span id="line2265">2265. </span>
  2270. <span id="line2266">2266. /* leave off "your" for most of your artifacts, but prepend</span>
  2271. <span id="line2267">2267. * "your" for unique objects and "foo of bar" quest artifacts */</span>
  2272. <span id="line2268">2268. if (!carried(obj) || !obj_is_pname(obj)</span>
  2273. <span id="line2269">2269. || obj->oartifact >= ART_ORB_OF_DETECTION) {</span>
  2274. <span id="line2270">2270. char *outbuf = shk_your(nextobuf(), obj);</span>
  2275. <span id="line2271">2271. int space_left = BUFSZ - 1 - Strlen(outbuf);</span>
  2276. <span id="line2272">2272. </span>
  2277. <span id="line2273">2273. s = strncat(outbuf, s, space_left);</span>
  2278. <span id="line2274">2274. }</span>
  2279. <span id="line2275">2275. return s;</span>
  2280. <span id="line2276">2276. }</span>
  2281. <span id="line2277">2277. </span>
  2282. <span id="line2278">2278. /* combine Yname2 and aobjnam eg "Your count cxname(otmp)" */</span>
  2283. <span id="line2279">2279. char *</span>
  2284. <span id="line2280">2280. Yobjnam2(struct obj *obj, const char *verb)</span>
  2285. <span id="line2281">2281. {</span>
  2286. <span id="line2282">2282. char *s = yobjnam(obj, verb);</span>
  2287. <span id="line2283">2283. </span>
  2288. <span id="line2284">2284. *s = highc(*s);</span>
  2289. <span id="line2285">2285. return s;</span>
  2290. <span id="line2286">2286. }</span>
  2291. <span id="line2287">2287. </span>
  2292. <span id="line2288">2288. /* like aobjnam, but prepend "The", not count, and use xname */</span>
  2293. <span id="line2289">2289. char *</span>
  2294. <span id="line2290">2290. Tobjnam(struct obj *otmp, const char *verb)</span>
  2295. <span id="line2291">2291. {</span>
  2296. <span id="line2292">2292. char *bp = The(xname(otmp));</span>
  2297. <span id="line2293">2293. </span>
  2298. <span id="line2294">2294. if (verb) {</span>
  2299. <span id="line2295">2295. Strcat(bp, " ");</span>
  2300. <span id="line2296">2296. Strcat(bp, otense(otmp, verb));</span>
  2301. <span id="line2297">2297. }</span>
  2302. <span id="line2298">2298. return bp;</span>
  2303. <span id="line2299">2299. }</span>
  2304. <span id="line2300">2300. </span>
  2305. <span id="line2301">2301. /* capitalized variant of doname() */</span>
  2306. <span id="line2302">2302. char *</span>
  2307. <span id="line2303">2303. Doname2(struct obj *obj)</span>
  2308. <span id="line2304">2304. {</span>
  2309. <span id="line2305">2305. char *s = doname(obj);</span>
  2310. <span id="line2306">2306. </span>
  2311. <span id="line2307">2307. *s = highc(*s);</span>
  2312. <span id="line2308">2308. return s;</span>
  2313. <span id="line2309">2309. }</span>
  2314. <span id="line2310">2310. </span>
  2315. <span id="line2311">2311. /* doname() for itemized buying of 'obj' from a shop */</span>
  2316. <span id="line2312">2312. char *</span>
  2317. <span id="line2313">2313. paydoname(struct obj *obj)</span>
  2318. <span id="line2314">2314. {</span>
  2319. <span id="line2315">2315. static const char and_contents[] = " and its contents";</span>
  2320. <span id="line2316">2316. char *p;</span>
  2321. <span id="line2317">2317. unsigned save_cknown = obj->cknown;</span>
  2322. <span id="line2318">2318. boolean save_wizweight = iflags.wizweight;</span>
  2323. <span id="line2319">2319. </span>
  2324. <span id="line2320">2320. if (Has_contents(obj))</span>
  2325. <span id="line2321">2321. obj->cknown = 0;</span>
  2326. <span id="line2322">2322. /* avoid showing item weights to unclutter billing's pay-menu a bit */</span>
  2327. <span id="line2323">2323. iflags.wizweight = FALSE;</span>
  2328. <span id="line2324">2324. /* suppress invent-style price; caller will add billing-style price */</span>
  2329. <span id="line2325">2325. iflags.suppress_price++;</span>
  2330. <span id="line2326">2326. p = doname_base(obj, 0U);</span>
  2331. <span id="line2327">2327. iflags.suppress_price--;</span>
  2332. <span id="line2328">2328. iflags.wizweight = save_wizweight;</span>
  2333. <span id="line2329">2329. </span>
  2334. <span id="line2330">2330. if (Has_contents(obj)) {</span>
  2335. <span id="line2331">2331. /* buy_container() sets no_charge for a container that has just</span>
  2336. <span id="line2332">2332. been purchased so that when paydoname() is called by</span>
  2337. <span id="line2333">2333. shk_names_obj(), we'll provide "a/an <container>" instead of</span>
  2338. <span id="line2334">2334. "your <container>" */</span>
  2339. <span id="line2335">2335. if (!obj->no_charge) {</span>
  2340. <span id="line2336">2336. if (!strncmp(p, "a ", 2))</span>
  2341. <span id="line2337">2337. p += 2;</span>
  2342. <span id="line2338">2338. else if (!strncmp(p, "an ", 3))</span>
  2343. <span id="line2339">2339. p += 3;</span>
  2344. <span id="line2340">2340. p = strprepend(p, obj->unpaid ? "an unpaid " : "your ");</span>
  2345. <span id="line2341">2341. }</span>
  2346. <span id="line2342">2342. </span>
  2347. <span id="line2343">2343. if (!obj->cknown) {</span>
  2348. <span id="line2344">2344. if (obj->unpaid) {</span>
  2349. <span id="line2345">2345. if ((int) strlen(p) + sizeof and_contents - 1</span>
  2350. <span id="line2346">2346. < BUFSZ - PREFIX)</span>
  2351. <span id="line2347">2347. Strcat(p, and_contents);</span>
  2352. <span id="line2348">2348. } else {</span>
  2353. <span id="line2349">2349. p = strprepend(p, "the contents of ");</span>
  2354. <span id="line2350">2350. }</span>
  2355. <span id="line2351">2351. }</span>
  2356. <span id="line2352">2352. }</span>
  2357. <span id="line2353">2353. obj->cknown = save_cknown;</span>
  2358. <span id="line2354">2354. return p;</span>
  2359. <span id="line2355">2355. }</span>
  2360. <span id="line2356">2356. </span>
  2361. <span id="line2357">2357. /* returns "[your ]xname(obj)" or "Foobar's xname(obj)" or "the xname(obj)" */</span>
  2362. <span id="line2358">2358. char *</span>
  2363. <span id="line2359">2359. yname(struct obj *obj)</span>
  2364. <span id="line2360">2360. {</span>
  2365. <span id="line2361">2361. char *s = cxname(obj);</span>
  2366. <span id="line2362">2362. </span>
  2367. <span id="line2363">2363. /* leave off "your" for most of your artifacts, but prepend</span>
  2368. <span id="line2364">2364. * "your" for unique objects and "foo of bar" quest artifacts */</span>
  2369. <span id="line2365">2365. if (!carried(obj) || !obj_is_pname(obj)</span>
  2370. <span id="line2366">2366. || obj->oartifact >= ART_ORB_OF_DETECTION) {</span>
  2371. <span id="line2367">2367. char *outbuf = shk_your(nextobuf(), obj);</span>
  2372. <span id="line2368">2368. int space_left = BUFSZ - 1 - Strlen(outbuf);</span>
  2373. <span id="line2369">2369. </span>
  2374. <span id="line2370">2370. s = strncat(outbuf, s, space_left);</span>
  2375. <span id="line2371">2371. }</span>
  2376. <span id="line2372">2372. </span>
  2377. <span id="line2373">2373. return s;</span>
  2378. <span id="line2374">2374. }</span>
  2379. <span id="line2375">2375. </span>
  2380. <span id="line2376">2376. /* capitalized variant of yname() */</span>
  2381. <span id="line2377">2377. char *</span>
  2382. <span id="line2378">2378. Yname2(struct obj *obj)</span>
  2383. <span id="line2379">2379. {</span>
  2384. <span id="line2380">2380. char *s = yname(obj);</span>
  2385. <span id="line2381">2381. </span>
  2386. <span id="line2382">2382. *s = highc(*s);</span>
  2387. <span id="line2383">2383. return s;</span>
  2388. <span id="line2384">2384. }</span>
  2389. <span id="line2385">2385. </span>
  2390. <span id="line2386">2386. /* returns "your minimal_xname(obj)"</span>
  2391. <span id="line2387">2387. * or "Foobar's minimal_xname(obj)"</span>
  2392. <span id="line2388">2388. * or "the minimal_xname(obj)"</span>
  2393. <span id="line2389">2389. */</span>
  2394. <span id="line2390">2390. char *</span>
  2395. <span id="line2391">2391. ysimple_name(struct obj *obj)</span>
  2396. <span id="line2392">2392. {</span>
  2397. <span id="line2393">2393. char *outbuf = nextobuf();</span>
  2398. <span id="line2394">2394. char *s = shk_your(outbuf, obj); /* assert( s == outbuf ); */</span>
  2399. <span id="line2395">2395. int space_left = BUFSZ - 1 - Strlen(s);</span>
  2400. <span id="line2396">2396. </span>
  2401. <span id="line2397">2397. return strncat(s, minimal_xname(obj), space_left);</span>
  2402. <span id="line2398">2398. }</span>
  2403. <span id="line2399">2399. </span>
  2404. <span id="line2400">2400. /* capitalized variant of ysimple_name() */</span>
  2405. <span id="line2401">2401. char *</span>
  2406. <span id="line2402">2402. Ysimple_name2(struct obj *obj)</span>
  2407. <span id="line2403">2403. {</span>
  2408. <span id="line2404">2404. char *s = ysimple_name(obj);</span>
  2409. <span id="line2405">2405. </span>
  2410. <span id="line2406">2406. *s = highc(*s);</span>
  2411. <span id="line2407">2407. return s;</span>
  2412. <span id="line2408">2408. }</span>
  2413. <span id="line2409">2409. </span>
  2414. <span id="line2410">2410. /*</span>
  2415. <span id="line2411">2411. * FIXME:</span>
  2416. <span id="line2412">2412. * simpleonames(), ansimpleoname(), and thesimpleoname() need to</span>
  2417. <span id="line2413">2413. * know the beginning of the obuf[] they use so that they can</span>
  2418. <span id="line2414">2414. * guard against buffer overflow when pluralizing (is that an</span>
  2419. <span id="line2415">2415. * actual word?) or inserting "an" or "the".</span>
  2420. <span id="line2416">2416. *</span>
  2421. <span id="line2417">2417. * minimal_xname() returns a call to xname() which writes into</span>
  2422. <span id="line2418">2418. * the middle of its obuf[] then backs up to accomodate a prefix,</span>
  2423. <span id="line2419">2419. * so BUFSZ is not a reliable limit for the length of the result.</span>
  2424. <span id="line2420">2420. *</span>
  2425. <span id="line2421">2421. * [Overflow likely moot. Since the formatted object name has</span>
  2426. <span id="line2422">2422. * user-supplied name suppressed, the length is sure to be short</span>
  2427. <span id="line2423">2423. * enough to added plural suffix or "an" or "the" prefix.]</span>
  2428. <span id="line2424">2424. */</span>
  2429. <span id="line2425">2425. </span>
  2430. <span id="line2426">2426. /* "scroll" or "scrolls" */</span>
  2431. <span id="line2427">2427. char *</span>
  2432. <span id="line2428">2428. simpleonames(struct obj *obj)</span>
  2433. <span id="line2429">2429. {</span>
  2434. <span id="line2430">2430. char *obufp, *simpleoname = minimal_xname(obj);</span>
  2435. <span id="line2431">2431. </span>
  2436. <span id="line2432">2432. if (obj->quan != 1L) {</span>
  2437. <span id="line2433">2433. /* 'simpleoname' points to an obuf; makeplural() will allocate</span>
  2438. <span id="line2434">2434. another one and only that one can be explicitly released for</span>
  2439. <span id="line2435">2435. re-use, so this is slightly convoluted to cope with that;</span>
  2440. <span id="line2436">2436. makeplural() will be fully evaluated and done with its input</span>
  2441. <span id="line2437">2437. argument before strcpy() touches its output argument */</span>
  2442. <span id="line2438">2438. Strcpy(simpleoname, obufp = makeplural(simpleoname));</span>
  2443. <span id="line2439">2439. releaseobuf(obufp);</span>
  2444. <span id="line2440">2440. }</span>
  2445. <span id="line2441">2441. return simpleoname;</span>
  2446. <span id="line2442">2442. }</span>
  2447. <span id="line2443">2443. </span>
  2448. <span id="line2444">2444. /* "a scroll" or "scrolls"; "a silver bell" or "the Bell of Opening" */</span>
  2449. <span id="line2445">2445. char *</span>
  2450. <span id="line2446">2446. ansimpleoname(struct obj *obj)</span>
  2451. <span id="line2447">2447. {</span>
  2452. <span id="line2448">2448. char *obufp, *simpleoname = simpleonames(obj);</span>
  2453. <span id="line2449">2449. int otyp = obj->otyp;</span>
  2454. <span id="line2450">2450. </span>
  2455. <span id="line2451">2451. /* prefix with "the" if a unique item, or a fake one imitating same,</span>
  2456. <span id="line2452">2452. has been formatted with its actual name (we let minimal_xname() handle</span>
  2457. <span id="line2453">2453. any `known' and `dknown' checking necessary) */</span>
  2458. <span id="line2454">2454. if (otyp == FAKE_AMULET_OF_YENDOR)</span>
  2459. <span id="line2455">2455. otyp = AMULET_OF_YENDOR;</span>
  2460. <span id="line2456">2456. if (objects[otyp].oc_unique && OBJ_NAME(objects[otyp])</span>
  2461. <span id="line2457">2457. && !strcmp(simpleoname, OBJ_NAME(objects[otyp]))) {</span>
  2462. <span id="line2458">2458. /* the() will allocate another obuf[]; we want to avoid using two */</span>
  2463. <span id="line2459">2459. obufp = the(simpleoname);</span>
  2464. <span id="line2460">2460. Strcpy(simpleoname, obufp);</span>
  2465. <span id="line2461">2461. releaseobuf(obufp);</span>
  2466. <span id="line2462">2462. } else if (obj->quan == 1L) {</span>
  2467. <span id="line2463">2463. /* simpleoname[] is singular if quan==1, plural otherwise;</span>
  2468. <span id="line2464">2464. an() will allocate another obuf[]; we want to avoid using two */</span>
  2469. <span id="line2465">2465. obufp = an(simpleoname);</span>
  2470. <span id="line2466">2466. Strcpy(simpleoname, obufp);</span>
  2471. <span id="line2467">2467. releaseobuf(obufp);</span>
  2472. <span id="line2468">2468. }</span>
  2473. <span id="line2469">2469. return simpleoname;</span>
  2474. <span id="line2470">2470. }</span>
  2475. <span id="line2471">2471. </span>
  2476. <span id="line2472">2472. /* "the scroll" or "the scrolls" */</span>
  2477. <span id="line2473">2473. char *</span>
  2478. <span id="line2474">2474. thesimpleoname(struct obj *obj)</span>
  2479. <span id="line2475">2475. {</span>
  2480. <span id="line2476">2476. char *obufp, *simpleoname = simpleonames(obj);</span>
  2481. <span id="line2477">2477. </span>
  2482. <span id="line2478">2478. /* the() will allocate another obuf[]; we want to avoid using two */</span>
  2483. <span id="line2479">2479. obufp = the(simpleoname);</span>
  2484. <span id="line2480">2480. Strcpy(simpleoname, obufp);</span>
  2485. <span id="line2481">2481. releaseobuf(obufp);</span>
  2486. <span id="line2482">2482. return simpleoname;</span>
  2487. <span id="line2483">2483. }</span>
  2488. <span id="line2484">2484. </span>
  2489. <span id="line2485">2485. /* basic name of obj, as if it has been discovered; for some types of</span>
  2490. <span id="line2486">2486. items, we can't just use OBJ_NAME() because it doesn't always include</span>
  2491. <span id="line2487">2487. the class (for instance "light" when we want "spellbook of light");</span>
  2492. <span id="line2488">2488. minimal_xname() uses xname() to get that */</span>
  2493. <span id="line2489">2489. char *</span>
  2494. <span id="line2490">2490. actualoname(struct obj *obj)</span>
  2495. <span id="line2491">2491. {</span>
  2496. <span id="line2492">2492. char *res;</span>
  2497. <span id="line2493">2493. </span>
  2498. <span id="line2494">2494. iflags.override_ID = TRUE;</span>
  2499. <span id="line2495">2495. res = minimal_xname(obj);</span>
  2500. <span id="line2496">2496. iflags.override_ID = FALSE;</span>
  2501. <span id="line2497">2497. return res;</span>
  2502. <span id="line2498">2498. }</span>
  2503. <span id="line2499">2499. </span>
  2504. <span id="line2500">2500. /* artifact's name without any object type or known/dknown/&c feedback */</span>
  2505. <span id="line2501">2501. char *</span>
  2506. <span id="line2502">2502. bare_artifactname(struct obj *obj)</span>
  2507. <span id="line2503">2503. {</span>
  2508. <span id="line2504">2504. char *outbuf;</span>
  2509. <span id="line2505">2505. </span>
  2510. <span id="line2506">2506. if (obj->oartifact) {</span>
  2511. <span id="line2507">2507. outbuf = nextobuf();</span>
  2512. <span id="line2508">2508. Strcpy(outbuf, artiname(obj->oartifact));</span>
  2513. <span id="line2509">2509. if (!strncmp(outbuf, "The ", 4))</span>
  2514. <span id="line2510">2510. outbuf[0] = lowc(outbuf[0]);</span>
  2515. <span id="line2511">2511. } else {</span>
  2516. <span id="line2512">2512. outbuf = xname(obj);</span>
  2517. <span id="line2513">2513. }</span>
  2518. <span id="line2514">2514. return outbuf;</span>
  2519. <span id="line2515">2515. }</span>
  2520. <span id="line2516">2516. </span>
  2521. <span id="line2517">2517. static const char *const wrp[] = {</span>
  2522. <span id="line2518">2518. "wand", "ring", "potion", "scroll", "gem",</span>
  2523. <span id="line2519">2519. "amulet", "spellbook", "spell book",</span>
  2524. <span id="line2520">2520. /* for non-specific wishes */</span>
  2525. <span id="line2521">2521. "weapon", "armor", "tool", "food", "comestible",</span>
  2526. <span id="line2522">2522. };</span>
  2527. <span id="line2523">2523. static const char wrpsym[] = { WAND_CLASS, RING_CLASS, POTION_CLASS,</span>
  2528. <span id="line2524">2524. SCROLL_CLASS, GEM_CLASS, AMULET_CLASS,</span>
  2529. <span id="line2525">2525. SPBOOK_CLASS, SPBOOK_CLASS, WEAPON_CLASS,</span>
  2530. <span id="line2526">2526. ARMOR_CLASS, TOOL_CLASS, FOOD_CLASS,</span>
  2531. <span id="line2527">2527. FOOD_CLASS };</span>
  2532. <span id="line2528">2528. </span>
  2533. <span id="line2529">2529. /* return form of the verb (input plural) if xname(otmp) were the subject */</span>
  2534. <span id="line2530">2530. char *</span>
  2535. <span id="line2531">2531. otense(struct obj *otmp, const char *verb)</span>
  2536. <span id="line2532">2532. {</span>
  2537. <span id="line2533">2533. char *buf;</span>
  2538. <span id="line2534">2534. </span>
  2539. <span id="line2535">2535. /*</span>
  2540. <span id="line2536">2536. * verb is given in plural (without trailing s). Return as input</span>
  2541. <span id="line2537">2537. * if the result of xname(otmp) would be plural. Don't bother</span>
  2542. <span id="line2538">2538. * recomputing xname(otmp) at this time.</span>
  2543. <span id="line2539">2539. */</span>
  2544. <span id="line2540">2540. if (!is_plural(otmp))</span>
  2545. <span id="line2541">2541. return vtense((char *) 0, verb);</span>
  2546. <span id="line2542">2542. </span>
  2547. <span id="line2543">2543. buf = nextobuf();</span>
  2548. <span id="line2544">2544. Strcpy(buf, verb);</span>
  2549. <span id="line2545">2545. return buf;</span>
  2550. <span id="line2546">2546. }</span>
  2551. <span id="line2547">2547. </span>
  2552. <span id="line2548">2548. /* various singular words that vtense would otherwise categorize as plural;</span>
  2553. <span id="line2549">2549. also used by makesingular() to catch some special cases */</span>
  2554. <span id="line2550">2550. static const char *const special_subjs[] = {</span>
  2555. <span id="line2551">2551. "erinys", "manes", /* this one is ambiguous */</span>
  2556. <span id="line2552">2552. "Cyclops", "Hippocrates", "Pelias", "aklys",</span>
  2557. <span id="line2553">2553. "amnesia", "detect monsters", "paralysis", "shape changers",</span>
  2558. <span id="line2554">2554. "nemesis", 0</span>
  2559. <span id="line2555">2555. /* note: "detect monsters" and "shape changers" are normally</span>
  2560. <span id="line2556">2556. caught via "<something>(s) of <whatever>", but they can be</span>
  2561. <span id="line2557">2557. wished for using the shorter form, so we include them here</span>
  2562. <span id="line2558">2558. to accommodate usage by makesingular during wishing */</span>
  2563. <span id="line2559">2559. };</span>
  2564. <span id="line2560">2560. </span>
  2565. <span id="line2561">2561. /* return form of the verb (input plural) for present tense 3rd person subj */</span>
  2566. <span id="line2562">2562. char *</span>
  2567. <span id="line2563">2563. vtense(const char *subj, const char *verb)</span>
  2568. <span id="line2564">2564. {</span>
  2569. <span id="line2565">2565. char *buf = nextobuf(), *bspot;</span>
  2570. <span id="line2566">2566. int len, ltmp;</span>
  2571. <span id="line2567">2567. const char *sp, *spot;</span>
  2572. <span id="line2568">2568. const char *const *spec;</span>
  2573. <span id="line2569">2569. </span>
  2574. <span id="line2570">2570. /*</span>
  2575. <span id="line2571">2571. * verb is given in plural (without trailing s). Return as input</span>
  2576. <span id="line2572">2572. * if subj appears to be plural. Add special cases as necessary.</span>
  2577. <span id="line2573">2573. * Many hard cases can already be handled by using otense() instead.</span>
  2578. <span id="line2574">2574. * If this gets much bigger, consider decomposing makeplural.</span>
  2579. <span id="line2575">2575. * Note: monster names are not expected here (except before corpse).</span>
  2580. <span id="line2576">2576. *</span>
  2581. <span id="line2577">2577. * Special case: allow null sobj to get the singular 3rd person</span>
  2582. <span id="line2578">2578. * present tense form so we don't duplicate this code elsewhere.</span>
  2583. <span id="line2579">2579. */</span>
  2584. <span id="line2580">2580. if (subj) {</span>
  2585. <span id="line2581">2581. if (!strncmpi(subj, "a ", 2) || !strncmpi(subj, "an ", 3))</span>
  2586. <span id="line2582">2582. goto sing;</span>
  2587. <span id="line2583">2583. spot = (const char *) 0;</span>
  2588. <span id="line2584">2584. for (sp = subj; (sp = strchr(sp, ' ')) != 0; ++sp) {</span>
  2589. <span id="line2585">2585. if (!strncmpi(sp, " of ", 4) || !strncmpi(sp, " from ", 6)</span>
  2590. <span id="line2586">2586. || !strncmpi(sp, " called ", 8) || !strncmpi(sp, " named ", 7)</span>
  2591. <span id="line2587">2587. || !strncmpi(sp, " labeled ", 9)) {</span>
  2592. <span id="line2588">2588. if (sp != subj)</span>
  2593. <span id="line2589">2589. spot = sp - 1;</span>
  2594. <span id="line2590">2590. break;</span>
  2595. <span id="line2591">2591. }</span>
  2596. <span id="line2592">2592. }</span>
  2597. <span id="line2593">2593. len = (int) strlen(subj);</span>
  2598. <span id="line2594">2594. if (!spot)</span>
  2599. <span id="line2595">2595. spot = subj + len - 1;</span>
  2600. <span id="line2596">2596. </span>
  2601. <span id="line2597">2597. /*</span>
  2602. <span id="line2598">2598. * plural: anything that ends in 's', but not '*us' or '*ss'.</span>
  2603. <span id="line2599">2599. * Guess at a few other special cases that makeplural creates.</span>
  2604. <span id="line2600">2600. */</span>
  2605. <span id="line2601">2601. if ((lowc(*spot) == 's' && spot != subj</span>
  2606. <span id="line2602">2602. && !strchr("us", lowc(*(spot - 1))))</span>
  2607. <span id="line2603">2603. || !BSTRNCMPI(subj, spot - 3, "eeth", 4)</span>
  2608. <span id="line2604">2604. || !BSTRNCMPI(subj, spot - 3, "feet", 4)</span>
  2609. <span id="line2605">2605. || !BSTRNCMPI(subj, spot - 1, "ia", 2)</span>
  2610. <span id="line2606">2606. || !BSTRNCMPI(subj, spot - 1, "ae", 2)) {</span>
  2611. <span id="line2607">2607. /* check for special cases to avoid false matches */</span>
  2612. <span id="line2608">2608. len = (int) (spot - subj) + 1;</span>
  2613. <span id="line2609">2609. for (spec = special_subjs; *spec; spec++) {</span>
  2614. <span id="line2610">2610. ltmp = Strlen(*spec);</span>
  2615. <span id="line2611">2611. if (len == ltmp && !strncmpi(*spec, subj, len))</span>
  2616. <span id="line2612">2612. goto sing;</span>
  2617. <span id="line2613">2613. /* also check for <prefix><space><special_subj></span>
  2618. <span id="line2614">2614. to catch things like "the invisible erinys" */</span>
  2619. <span id="line2615">2615. if (len > ltmp && *(spot - ltmp) == ' '</span>
  2620. <span id="line2616">2616. && !strncmpi(*spec, spot - ltmp + 1, ltmp))</span>
  2621. <span id="line2617">2617. goto sing;</span>
  2622. <span id="line2618">2618. }</span>
  2623. <span id="line2619">2619. </span>
  2624. <span id="line2620">2620. return strcpy(buf, verb);</span>
  2625. <span id="line2621">2621. }</span>
  2626. <span id="line2622">2622. /*</span>
  2627. <span id="line2623">2623. * 3rd person plural doesn't end in telltale 's';</span>
  2628. <span id="line2624">2624. * 2nd person singular behaves as if plural.</span>
  2629. <span id="line2625">2625. */</span>
  2630. <span id="line2626">2626. if (!strcmpi(subj, "they") || !strcmpi(subj, "you"))</span>
  2631. <span id="line2627">2627. return strcpy(buf, verb);</span>
  2632. <span id="line2628">2628. }</span>
  2633. <span id="line2629">2629. </span>
  2634. <span id="line2630">2630. sing:</span>
  2635. <span id="line2631">2631. Strcpy(buf, verb);</span>
  2636. <span id="line2632">2632. len = (int) strlen(buf);</span>
  2637. <span id="line2633">2633. bspot = buf + len - 1;</span>
  2638. <span id="line2634">2634. </span>
  2639. <span id="line2635">2635. if (!strcmpi(buf, "are")) {</span>
  2640. <span id="line2636">2636. Strcasecpy(buf, "is");</span>
  2641. <span id="line2637">2637. } else if (!strcmpi(buf, "have")) {</span>
  2642. <span id="line2638">2638. Strcasecpy(bspot - 1, "s");</span>
  2643. <span id="line2639">2639. } else if (strchr("zxs", lowc(*bspot))</span>
  2644. <span id="line2640">2640. || (len >= 2 && lowc(*bspot) == 'h'</span>
  2645. <span id="line2641">2641. && strchr("cs", lowc(*(bspot - 1))))</span>
  2646. <span id="line2642">2642. || (len == 2 && lowc(*bspot) == 'o')) {</span>
  2647. <span id="line2643">2643. /* Ends in z, x, s, ch, sh; add an "es" */</span>
  2648. <span id="line2644">2644. Strcasecpy(bspot + 1, "es");</span>
  2649. <span id="line2645">2645. } else if (lowc(*bspot) == 'y' && !strchr(vowels, lowc(*(bspot - 1)))) {</span>
  2650. <span id="line2646">2646. /* like "y" case in makeplural */</span>
  2651. <span id="line2647">2647. Strcasecpy(bspot, "ies");</span>
  2652. <span id="line2648">2648. } else {</span>
  2653. <span id="line2649">2649. Strcasecpy(bspot + 1, "s");</span>
  2654. <span id="line2650">2650. }</span>
  2655. <span id="line2651">2651. </span>
  2656. <span id="line2652">2652. return buf;</span>
  2657. <span id="line2653">2653. }</span>
  2658. <span id="line2654">2654. </span>
  2659. <span id="line2655">2655. struct sing_plur {</span>
  2660. <span id="line2656">2656. const char *sing, *plur;</span>
  2661. <span id="line2657">2657. };</span>
  2662. <span id="line2658">2658. </span>
  2663. <span id="line2659">2659. /* word pairs that don't fit into formula-based transformations;</span>
  2664. <span id="line2660">2660. also some suffices which have very few--often one--matches or</span>
  2665. <span id="line2661">2661. which aren't systematically reversible (knives, staves) */</span>
  2666. <span id="line2662">2662. static const struct sing_plur one_off[] = {</span>
  2667. <span id="line2663">2663. { "child",</span>
  2668. <span id="line2664">2664. "children" }, /* (for wise guys who give their food funny names) */</span>
  2669. <span id="line2665">2665. { "cubus", "cubi" }, /* in-/suc-cubus */</span>
  2670. <span id="line2666">2666. { "culus", "culi" }, /* homunculus */</span>
  2671. <span id="line2667">2667. { "Cyclops", "Cyclopes" },</span>
  2672. <span id="line2668">2668. { "djinni", "djinn" },</span>
  2673. <span id="line2669">2669. { "erinys", "erinyes" },</span>
  2674. <span id="line2670">2670. { "foot", "feet" },</span>
  2675. <span id="line2671">2671. { "fungus", "fungi" },</span>
  2676. <span id="line2672">2672. { "goose", "geese" },</span>
  2677. <span id="line2673">2673. { "knife", "knives" },</span>
  2678. <span id="line2674">2674. { "labrum", "labra" }, /* candelabrum */</span>
  2679. <span id="line2675">2675. { "louse", "lice" },</span>
  2680. <span id="line2676">2676. { "mouse", "mice" },</span>
  2681. <span id="line2677">2677. { "mumak", "mumakil" },</span>
  2682. <span id="line2678">2678. { "nemesis", "nemeses" },</span>
  2683. <span id="line2679">2679. { "ovum", "ova" },</span>
  2684. <span id="line2680">2680. { "ox", "oxen" },</span>
  2685. <span id="line2681">2681. { "passerby", "passersby" },</span>
  2686. <span id="line2682">2682. { "rtex", "rtices" }, /* vortex */</span>
  2687. <span id="line2683">2683. { "serum", "sera" },</span>
  2688. <span id="line2684">2684. { "staff", "staves" },</span>
  2689. <span id="line2685">2685. { "tooth", "teeth" },</span>
  2690. <span id="line2686">2686. { 0, 0 }</span>
  2691. <span id="line2687">2687. };</span>
  2692. <span id="line2688">2688. </span>
  2693. <span id="line2689">2689. static const char *const as_is[] = {</span>
  2694. <span id="line2690">2690. /* makesingular() leaves these plural due to how they're used */</span>
  2695. <span id="line2691">2691. "boots", "shoes", "gloves", "lenses", "scales",</span>
  2696. <span id="line2692">2692. "eyes", "gauntlets", "iron bars",</span>
  2697. <span id="line2693">2693. /* both singular and plural are spelled the same */</span>
  2698. <span id="line2694">2694. "bison", "deer", "elk", "fish", "fowl",</span>
  2699. <span id="line2695">2695. "tuna", "yaki", "-hai", "krill", "manes",</span>
  2700. <span id="line2696">2696. "moose", "ninja", "sheep", "ronin", "roshi",</span>
  2701. <span id="line2697">2697. "shito", "tengu", "ki-rin", "Nazgul", "gunyoki",</span>
  2702. <span id="line2698">2698. "piranha", "samurai", "shuriken", "haggis", "Bordeaux",</span>
  2703. <span id="line2699">2699. 0,</span>
  2704. <span id="line2700">2700. /* Note: "fish" and "piranha" are collective plurals, suitable</span>
  2705. <span id="line2701">2701. for "wiped out all <foo>". For "3 <foo>", they should be</span>
  2706. <span id="line2702">2702. "fishes" and "piranhas" instead. We settle for collective</span>
  2707. <span id="line2703">2703. variant instead of attempting to support both. */</span>
  2708. <span id="line2704">2704. };</span>
  2709. <span id="line2705">2705. </span>
  2710. <span id="line2706">2706. /* singularize/pluralize decisions common to both makesingular & makeplural */</span>
  2711. <span id="line2707">2707. staticfn boolean</span>
  2712. <span id="line2708">2708. singplur_lookup(</span>
  2713. <span id="line2709">2709. char *basestr, char *endstring, /* base string, pointer to eos(string) */</span>
  2714. <span id="line2710">2710. boolean to_plural, /* true => makeplural, false => makesingular */</span>
  2715. <span id="line2711">2711. const char *const *alt_as_is) /* another set like as_is[] */</span>
  2716. <span id="line2712">2712. {</span>
  2717. <span id="line2713">2713. const struct sing_plur *sp;</span>
  2718. <span id="line2714">2714. const char *same, *other, *const *as;</span>
  2719. <span id="line2715">2715. int al;</span>
  2720. <span id="line2716">2716. int baselen = Strlen(basestr);</span>
  2721. <span id="line2717">2717. </span>
  2722. <span id="line2718">2718. for (as = as_is; *as; ++as) {</span>
  2723. <span id="line2719">2719. al = (int) strlen(*as);</span>
  2724. <span id="line2720">2720. if (!BSTRCMPI(basestr, endstring - al, *as))</span>
  2725. <span id="line2721">2721. return TRUE;</span>
  2726. <span id="line2722">2722. }</span>
  2727. <span id="line2723">2723. if (alt_as_is) {</span>
  2728. <span id="line2724">2724. for (as = alt_as_is; *as; ++as) {</span>
  2729. <span id="line2725">2725. al = (int) strlen(*as);</span>
  2730. <span id="line2726">2726. if (!BSTRCMPI(basestr, endstring - al, *as))</span>
  2731. <span id="line2727">2727. return TRUE;</span>
  2732. <span id="line2728">2728. }</span>
  2733. <span id="line2729">2729. }</span>
  2734. <span id="line2730">2730. </span>
  2735. <span id="line2731">2731. /* Leave "craft" as a suffix as-is (aircraft, hovercraft);</span>
  2736. <span id="line2732">2732. "craft" itself is (arguably) not included in our likely context */</span>
  2737. <span id="line2733">2733. if ((baselen > 5) && (!BSTRCMPI(basestr, endstring - 5, "craft")))</span>
  2738. <span id="line2734">2734. return TRUE;</span>
  2739. <span id="line2735">2735. /* avoid false hit on one_off[].plur == "lice" or .sing == "goose";</span>
  2740. <span id="line2736">2736. if more of these turn up, one_off[] entries will need to flagged</span>
  2741. <span id="line2737">2737. as to which are whole words and which are matchable as suffices</span>
  2742. <span id="line2738">2738. then matching in the loop below will end up becoming more complex */</span>
  2743. <span id="line2739">2739. if (!strcmpi(basestr, "slice")</span>
  2744. <span id="line2740">2740. || !strcmpi(basestr, "mongoose")) {</span>
  2745. <span id="line2741">2741. if (to_plural)</span>
  2746. <span id="line2742">2742. Strcasecpy(endstring, "s");</span>
  2747. <span id="line2743">2743. return TRUE;</span>
  2748. <span id="line2744">2744. }</span>
  2749. <span id="line2745">2745. /* skip "ox" -> "oxen" entry when pluralizing "<something>ox"</span>
  2750. <span id="line2746">2746. unless it is muskox */</span>
  2751. <span id="line2747">2747. if (to_plural && baselen > 2 && !strcmpi(endstring - 2, "ox")</span>
  2752. <span id="line2748">2748. && !(baselen > 5 && !strcmpi(endstring - 6, "muskox"))) {</span>
  2753. <span id="line2749">2749. /* "fox" -> "foxes" */</span>
  2754. <span id="line2750">2750. Strcasecpy(endstring, "es");</span>
  2755. <span id="line2751">2751. return TRUE;</span>
  2756. <span id="line2752">2752. }</span>
  2757. <span id="line2753">2753. if (to_plural) {</span>
  2758. <span id="line2754">2754. if (baselen > 2 && !strcmpi(endstring - 3, "man")</span>
  2759. <span id="line2755">2755. && badman(basestr, to_plural)) {</span>
  2760. <span id="line2756">2756. Strcasecpy(endstring, "s");</span>
  2761. <span id="line2757">2757. return TRUE;</span>
  2762. <span id="line2758">2758. }</span>
  2763. <span id="line2759">2759. } else {</span>
  2764. <span id="line2760">2760. if (baselen > 2 && !strcmpi(endstring - 3, "men")</span>
  2765. <span id="line2761">2761. && badman(basestr, to_plural))</span>
  2766. <span id="line2762">2762. return TRUE;</span>
  2767. <span id="line2763">2763. }</span>
  2768. <span id="line2764">2764. for (sp = one_off; sp->sing; sp++) {</span>
  2769. <span id="line2765">2765. /* check whether endstring already matches */</span>
  2770. <span id="line2766">2766. same = to_plural ? sp->plur : sp->sing;</span>
  2771. <span id="line2767">2767. al = (int) strlen(same);</span>
  2772. <span id="line2768">2768. if (!BSTRCMPI(basestr, endstring - al, same))</span>
  2773. <span id="line2769">2769. return TRUE; /* use as-is */</span>
  2774. <span id="line2770">2770. /* check whether it matches the inverse; if so, transform it */</span>
  2775. <span id="line2771">2771. other = to_plural ? sp->sing : sp->plur;</span>
  2776. <span id="line2772">2772. al = (int) strlen(other);</span>
  2777. <span id="line2773">2773. if (!BSTRCMPI(basestr, endstring - al, other)) {</span>
  2778. <span id="line2774">2774. Strcasecpy(endstring - al, same);</span>
  2779. <span id="line2775">2775. return TRUE; /* one_off[] transformation */</span>
  2780. <span id="line2776">2776. }</span>
  2781. <span id="line2777">2777. }</span>
  2782. <span id="line2778">2778. return FALSE;</span>
  2783. <span id="line2779">2779. }</span>
  2784. <span id="line2780">2780. </span>
  2785. <span id="line2781">2781. /* searches for common compounds, ex. lump of royal jelly */</span>
  2786. <span id="line2782">2782. staticfn char *</span>
  2787. <span id="line2783">2783. singplur_compound(char *str)</span>
  2788. <span id="line2784">2784. {</span>
  2789. <span id="line2785">2785. /* if new entries are added, be sure to keep compound_start[] in sync */</span>
  2790. <span id="line2786">2786. static const char *const compounds[] =</span>
  2791. <span id="line2787">2787. {</span>
  2792. <span id="line2788">2788. " of ", " labeled ", " called ",</span>
  2793. <span id="line2789">2789. " named ", " above", /* lurkers above */</span>
  2794. <span id="line2790">2790. " versus ", " from ", " in ",</span>
  2795. <span id="line2791">2791. " on ", " a la ", " with", /* " with "? */</span>
  2796. <span id="line2792">2792. " de ", " d'", " du ",</span>
  2797. <span id="line2793">2793. " au ", "-in-", "-at-",</span>
  2798. <span id="line2794">2794. 0</span>
  2799. <span id="line2795">2795. }, /* list of first characters for all compounds[] entries */</span>
  2800. <span id="line2796">2796. compound_start[] = " -";</span>
  2801. <span id="line2797">2797. </span>
  2802. <span id="line2798">2798. const char *const *cmpd;</span>
  2803. <span id="line2799">2799. char *p;</span>
  2804. <span id="line2800">2800. </span>
  2805. <span id="line2801">2801. for (p = str; *p; ++p) {</span>
  2806. <span id="line2802">2802. /* substring starting at p can only match if *p is found</span>
  2807. <span id="line2803">2803. within compound_start[] */</span>
  2808. <span id="line2804">2804. if (!strchr(compound_start, *p))</span>
  2809. <span id="line2805">2805. continue;</span>
  2810. <span id="line2806">2806. </span>
  2811. <span id="line2807">2807. /* check current substring against all words in the compound[] list */</span>
  2812. <span id="line2808">2808. for (cmpd = compounds; *cmpd; ++cmpd)</span>
  2813. <span id="line2809">2809. if (!strncmpi(p, *cmpd, (int) strlen(*cmpd)))</span>
  2814. <span id="line2810">2810. return p;</span>
  2815. <span id="line2811">2811. }</span>
  2816. <span id="line2812">2812. /* wasn't recognized as a compound phrase */</span>
  2817. <span id="line2813">2813. return 0;</span>
  2818. <span id="line2814">2814. }</span>
  2819. <span id="line2815">2815. </span>
  2820. <span id="line2816">2816. /* Plural routine; once upon a time it may have been chiefly used for</span>
  2821. <span id="line2817">2817. * user-defined fruits, but it is now used extensively throughout the</span>
  2822. <span id="line2818">2818. * program.</span>
  2823. <span id="line2819">2819. *</span>
  2824. <span id="line2820">2820. * For fruit, we have to try to account for everything reasonable the</span>
  2825. <span id="line2821">2821. * player has; something unreasonable can still break the code.</span>
  2826. <span id="line2822">2822. * However, it's still a lot more accurate than "just add an 's' at the</span>
  2827. <span id="line2823">2823. * end", which Rogue uses...</span>
  2828. <span id="line2824">2824. *</span>
  2829. <span id="line2825">2825. * Also used for plural monster names ("Wiped out all homunculi." or the</span>
  2830. <span id="line2826">2826. * vanquished monsters list) and body parts. A lot of unique monsters have</span>
  2831. <span id="line2827">2827. * names which get mangled by makeplural and/or makesingular. They're not</span>
  2832. <span id="line2828">2828. * genocidable, and vanquished-mon handling does its own special casing</span>
  2833. <span id="line2829">2829. * (for uniques who've been revived and re-killed), so we don't bother</span>
  2834. <span id="line2830">2830. * trying to get those right here.</span>
  2835. <span id="line2831">2831. *</span>
  2836. <span id="line2832">2832. * Also misused by muse.c to convert 1st person present verbs to 2nd person.</span>
  2837. <span id="line2833">2833. * 3.6.0: made case-insensitive.</span>
  2838. <span id="line2834">2834. */</span>
  2839. <span id="line2835">2835. char *</span>
  2840. <span id="line2836">2836. makeplural(const char *oldstr)</span>
  2841. <span id="line2837">2837. {</span>
  2842. <span id="line2838">2838. char *spot;</span>
  2843. <span id="line2839">2839. char lo_c, *str = nextobuf();</span>
  2844. <span id="line2840">2840. const char *excess = (char *) 0;</span>
  2845. <span id="line2841">2841. int len, i;</span>
  2846. <span id="line2842">2842. </span>
  2847. <span id="line2843">2843. if (oldstr)</span>
  2848. <span id="line2844">2844. while (*oldstr == ' ')</span>
  2849. <span id="line2845">2845. oldstr++;</span>
  2850. <span id="line2846">2846. if (!oldstr || !*oldstr) {</span>
  2851. <span id="line2847">2847. impossible("plural of null?");</span>
  2852. <span id="line2848">2848. Strcpy(str, "s");</span>
  2853. <span id="line2849">2849. return str;</span>
  2854. <span id="line2850">2850. }</span>
  2855. <span id="line2851">2851. /* makeplural() is sometimes used on monsters rather than objects</span>
  2856. <span id="line2852">2852. and sometimes pronouns are used for monsters, so check those;</span>
  2857. <span id="line2853">2853. unfortunately, "her" (which matches genders[1].him and [1].his)</span>
  2858. <span id="line2854">2854. and "it" (which matches genders[2].he and [2].him) are ambiguous;</span>
  2859. <span id="line2855">2855. we'll live with that; caller can fix things up if necessary */</span>
  2860. <span id="line2856">2856. *str = '\0';</span>
  2861. <span id="line2857">2857. for (i = 0; i <= 2; ++i) {</span>
  2862. <span id="line2858">2858. if (!strcmpi(genders[i].he, oldstr))</span>
  2863. <span id="line2859">2859. Strcpy(str, genders[3].he); /* "they" */</span>
  2864. <span id="line2860">2860. else if (!strcmpi(genders[i].him, oldstr))</span>
  2865. <span id="line2861">2861. Strcpy(str, genders[3].him); /* "them" */</span>
  2866. <span id="line2862">2862. else if (!strcmpi(genders[i].his, oldstr))</span>
  2867. <span id="line2863">2863. Strcpy(str, genders[3].his); /* "their" */</span>
  2868. <span id="line2864">2864. if (*str) {</span>
  2869. <span id="line2865">2865. if (oldstr[0] == highc(oldstr[0]))</span>
  2870. <span id="line2866">2866. str[0] = highc(str[0]);</span>
  2871. <span id="line2867">2867. return str;</span>
  2872. <span id="line2868">2868. }</span>
  2873. <span id="line2869">2869. }</span>
  2874. <span id="line2870">2870. </span>
  2875. <span id="line2871">2871. Strcpy(str, oldstr);</span>
  2876. <span id="line2872">2872. </span>
  2877. <span id="line2873">2873. /*</span>
  2878. <span id="line2874">2874. * Skip changing "pair of" to "pairs of". According to Webster, usual</span>
  2879. <span id="line2875">2875. * English usage is use pairs for humans, e.g. 3 pairs of dancers,</span>
  2880. <span id="line2876">2876. * and pair for objects and non-humans, e.g. 3 pair of boots. We don't</span>
  2881. <span id="line2877">2877. * refer to pairs of humans in this game so just skip to the bottom.</span>
  2882. <span id="line2878">2878. */</span>
  2883. <span id="line2879">2879. if (!strncmpi(str, "pair of ", 8))</span>
  2884. <span id="line2880">2880. goto bottom;</span>
  2885. <span id="line2881">2881. </span>
  2886. <span id="line2882">2882. /* look for "foo of bar" so that we can focus on "foo" */</span>
  2887. <span id="line2883">2883. if ((spot = singplur_compound(str)) != 0) {</span>
  2888. <span id="line2884">2884. excess = oldstr + (int) (spot - str);</span>
  2889. <span id="line2885">2885. *spot = '\0';</span>
  2890. <span id="line2886">2886. } else</span>
  2891. <span id="line2887">2887. spot = eos(str);</span>
  2892. <span id="line2888">2888. </span>
  2893. <span id="line2889">2889. spot--;</span>
  2894. <span id="line2890">2890. while (spot > str && *spot == ' ')</span>
  2895. <span id="line2891">2891. spot--; /* Strip blanks from end */</span>
  2896. <span id="line2892">2892. *(spot + 1) = '\0';</span>
  2897. <span id="line2893">2893. /* Now spot is the last character of the string */</span>
  2898. <span id="line2894">2894. </span>
  2899. <span id="line2895">2895. len = Strlen(str);</span>
  2900. <span id="line2896">2896. </span>
  2901. <span id="line2897">2897. /* Single letters */</span>
  2902. <span id="line2898">2898. if (len == 1 || !letter(*spot)) {</span>
  2903. <span id="line2899">2899. Strcpy(spot + 1, "'s");</span>
  2904. <span id="line2900">2900. goto bottom;</span>
  2905. <span id="line2901">2901. }</span>
  2906. <span id="line2902">2902. </span>
  2907. <span id="line2903">2903. /* dispense with some words which don't need pluralization */</span>
  2908. <span id="line2904">2904. {</span>
  2909. <span id="line2905">2905. static const char *const already_plural[] = {</span>
  2910. <span id="line2906">2906. "ae", /* algae, larvae, &c */</span>
  2911. <span id="line2907">2907. "eaux", /* chateaux, gateaux */</span>
  2912. <span id="line2908">2908. "matzot", 0,</span>
  2913. <span id="line2909">2909. };</span>
  2914. <span id="line2910">2910. </span>
  2915. <span id="line2911">2911. /* spot+1: synch up with makesingular's usage */</span>
  2916. <span id="line2912">2912. if (singplur_lookup(str, spot + 1, TRUE, already_plural))</span>
  2917. <span id="line2913">2913. goto bottom;</span>
  2918. <span id="line2914">2914. </span>
  2919. <span id="line2915">2915. /* more of same, but not suitable for blanket loop checking */</span>
  2920. <span id="line2916">2916. if ((len == 2 && !strcmpi(str, "ya"))</span>
  2921. <span id="line2917">2917. || (len >= 3 && !strcmpi(spot - 2, " ya")))</span>
  2922. <span id="line2918">2918. goto bottom;</span>
  2923. <span id="line2919">2919. }</span>
  2924. <span id="line2920">2920. </span>
  2925. <span id="line2921">2921. /* man/men ("Wiped out all cavemen.") */</span>
  2926. <span id="line2922">2922. if (len >= 3 && !strcmpi(spot - 2, "man")</span>
  2927. <span id="line2923">2923. /* exclude shamans and humans etc */</span>
  2928. <span id="line2924">2924. && !badman(str, TRUE)) {</span>
  2929. <span id="line2925">2925. Strcasecpy(spot - 1, "en");</span>
  2930. <span id="line2926">2926. goto bottom;</span>
  2931. <span id="line2927">2927. }</span>
  2932. <span id="line2928">2928. if (lowc(*spot) == 'f') { /* (staff handled via one_off[]) */</span>
  2933. <span id="line2929">2929. lo_c = lowc(*(spot - 1));</span>
  2934. <span id="line2930">2930. if (len >= 3 && !strcmpi(spot - 2, "erf")) {</span>
  2935. <span id="line2931">2931. /* avoid "nerf" -> "nerves", "serf" -> "serves" */</span>
  2936. <span id="line2932">2932. ; /* fall through to default (append 's') */</span>
  2937. <span id="line2933">2933. } else if (strchr("lr", lo_c) || strchr(vowels, lo_c)) {</span>
  2938. <span id="line2934">2934. /* [aeioulr]f to [aeioulr]ves */</span>
  2939. <span id="line2935">2935. Strcasecpy(spot, "ves");</span>
  2940. <span id="line2936">2936. goto bottom;</span>
  2941. <span id="line2937">2937. }</span>
  2942. <span id="line2938">2938. }</span>
  2943. <span id="line2939">2939. /* ium/ia (mycelia, baluchitheria) */</span>
  2944. <span id="line2940">2940. if (len >= 3 && !strcmpi(spot - 2, "ium")) {</span>
  2945. <span id="line2941">2941. Strcasecpy(spot - 2, "ia");</span>
  2946. <span id="line2942">2942. goto bottom;</span>
  2947. <span id="line2943">2943. }</span>
  2948. <span id="line2944">2944. /* algae, larvae, hyphae (another fungus part) */</span>
  2949. <span id="line2945">2945. if ((len >= 4 && !strcmpi(spot - 3, "alga"))</span>
  2950. <span id="line2946">2946. || (len >= 5</span>
  2951. <span id="line2947">2947. && (!strcmpi(spot - 4, "hypha") || !strcmpi(spot - 4, "larva")))</span>
  2952. <span id="line2948">2948. || (len >= 6 && !strcmpi(spot - 5, "amoeba"))</span>
  2953. <span id="line2949">2949. || (len >= 8 && (!strcmpi(spot - 7, "vertebra")))) {</span>
  2954. <span id="line2950">2950. /* a to ae */</span>
  2955. <span id="line2951">2951. Strcasecpy(spot + 1, "e");</span>
  2956. <span id="line2952">2952. goto bottom;</span>
  2957. <span id="line2953">2953. }</span>
  2958. <span id="line2954">2954. /* fungus/fungi, homunculus/homunculi, but buses, lotuses, wumpuses */</span>
  2959. <span id="line2955">2955. if (len > 3 && !strcmpi(spot - 1, "us")</span>
  2960. <span id="line2956">2956. && !((len >= 5 && !strcmpi(spot - 4, "lotus"))</span>
  2961. <span id="line2957">2957. || (len >= 6 && !strcmpi(spot - 5, "wumpus")))) {</span>
  2962. <span id="line2958">2958. Strcasecpy(spot - 1, "i");</span>
  2963. <span id="line2959">2959. goto bottom;</span>
  2964. <span id="line2960">2960. }</span>
  2965. <span id="line2961">2961. /* sis/ses (nemesis) */</span>
  2966. <span id="line2962">2962. if (len >= 3 && !strcmpi(spot - 2, "sis")) {</span>
  2967. <span id="line2963">2963. Strcasecpy(spot - 1, "es");</span>
  2968. <span id="line2964">2964. goto bottom;</span>
  2969. <span id="line2965">2965. }</span>
  2970. <span id="line2966">2966. /* -eau/-eaux (gateau, chapeau...) */</span>
  2971. <span id="line2967">2967. if (len >= 3 && !strcmpi(spot - 2, "eau")</span>
  2972. <span id="line2968">2968. /* 'bureaus' is the more common plural of 'bureau' */</span>
  2973. <span id="line2969">2969. && BSTRCMPI(str, spot - 5, "bureau")) {</span>
  2974. <span id="line2970">2970. Strcasecpy(spot + 1, "x");</span>
  2975. <span id="line2971">2971. goto bottom;</span>
  2976. <span id="line2972">2972. }</span>
  2977. <span id="line2973">2973. /* matzoh/matzot, possible food name */</span>
  2978. <span id="line2974">2974. if (len >= 6</span>
  2979. <span id="line2975">2975. && (!strcmpi(spot - 5, "matzoh") || !strcmpi(spot - 5, "matzah"))) {</span>
  2980. <span id="line2976">2976. Strcasecpy(spot - 1, "ot"); /* oh/ah -> ot */</span>
  2981. <span id="line2977">2977. goto bottom;</span>
  2982. <span id="line2978">2978. }</span>
  2983. <span id="line2979">2979. if (len >= 5</span>
  2984. <span id="line2980">2980. && (!strcmpi(spot - 4, "matzo") || !strcmpi(spot - 4, "matza"))) {</span>
  2985. <span id="line2981">2981. Strcasecpy(spot, "ot"); /* o/a -> ot */</span>
  2986. <span id="line2982">2982. goto bottom;</span>
  2987. <span id="line2983">2983. }</span>
  2988. <span id="line2984">2984. </span>
  2989. <span id="line2985">2985. /* note: ox/oxen, VAX/VAXen, goose/geese */</span>
  2990. <span id="line2986">2986. </span>
  2991. <span id="line2987">2987. lo_c = lowc(*spot);</span>
  2992. <span id="line2988">2988. </span>
  2993. <span id="line2989">2989. /* codex/spadix/neocortex and the like */</span>
  2994. <span id="line2990">2990. if (len >= 5</span>
  2995. <span id="line2991">2991. && (!strcmpi(spot - 2, "dex")</span>
  2996. <span id="line2992">2992. ||!strcmpi(spot - 2, "dix")</span>
  2997. <span id="line2993">2993. ||!strcmpi(spot - 2, "tex"))</span>
  2998. <span id="line2994">2994. /* indices would have been ok too, but stick with indexes */</span>
  2999. <span id="line2995">2995. && (strcmpi(spot - 4,"index") != 0)) {</span>
  3000. <span id="line2996">2996. Strcasecpy(spot - 1, "ices"); /* ex|ix -> ices */</span>
  3001. <span id="line2997">2997. goto bottom;</span>
  3002. <span id="line2998">2998. }</span>
  3003. <span id="line2999">2999. /* Ends in z, x, s, ch, sh; add an "es" */</span>
  3004. <span id="line3000">3000. if (strchr("zxs", lo_c)</span>
  3005. <span id="line3001">3001. || (len >= 2 && lo_c == 'h' && strchr("cs", lowc(*(spot - 1)))</span>
  3006. <span id="line3002">3002. /* 21st century k-sound */</span>
  3007. <span id="line3003">3003. && !(len >= 4 && lowc(*(spot - 1)) == 'c' && ch_ksound(str)))</span>
  3008. <span id="line3004">3004. /* Kludge to get "tomatoes" and "potatoes" right */</span>
  3009. <span id="line3005">3005. || (len >= 4 && !strcmpi(spot - 2, "ato"))</span>
  3010. <span id="line3006">3006. || (len >= 5 && !strcmpi(spot - 4, "dingo"))) {</span>
  3011. <span id="line3007">3007. Strcasecpy(spot + 1, "es"); /* append es */</span>
  3012. <span id="line3008">3008. goto bottom;</span>
  3013. <span id="line3009">3009. }</span>
  3014. <span id="line3010">3010. /* Ends in y preceded by consonant (note: also "qu") change to "ies" */</span>
  3015. <span id="line3011">3011. if (lo_c == 'y' && !strchr(vowels, lowc(*(spot - 1)))) {</span>
  3016. <span id="line3012">3012. Strcasecpy(spot, "ies"); /* y -> ies */</span>
  3017. <span id="line3013">3013. goto bottom;</span>
  3018. <span id="line3014">3014. }</span>
  3019. <span id="line3015">3015. /* Default: append an 's' */</span>
  3020. <span id="line3016">3016. Strcasecpy(spot + 1, "s");</span>
  3021. <span id="line3017">3017. </span>
  3022. <span id="line3018">3018. bottom:</span>
  3023. <span id="line3019">3019. if (excess)</span>
  3024. <span id="line3020">3020. Strcat(str, excess);</span>
  3025. <span id="line3021">3021. return str;</span>
  3026. <span id="line3022">3022. }</span>
  3027. <span id="line3023">3023. </span>
  3028. <span id="line3024">3024. /*</span>
  3029. <span id="line3025">3025. * Singularize a string the user typed in; this helps reduce the complexity</span>
  3030. <span id="line3026">3026. * of readobjnam, and is also used in pager.c to singularize the string</span>
  3031. <span id="line3027">3027. * for which help is sought.</span>
  3032. <span id="line3028">3028. *</span>
  3033. <span id="line3029">3029. * "Manes" is ambiguous: monster type (keep s), or horse body part (drop s)?</span>
  3034. <span id="line3030">3030. * Its inclusion in as_is[]/special_subj[] makes it get treated as the former.</span>
  3035. <span id="line3031">3031. *</span>
  3036. <span id="line3032">3032. * A lot of unique monsters have names ending in s; plural, or singular</span>
  3037. <span id="line3033">3033. * from plural, doesn't make much sense for them so we don't bother trying.</span>
  3038. <span id="line3034">3034. * 3.6.0: made case-insensitive.</span>
  3039. <span id="line3035">3035. */</span>
  3040. <span id="line3036">3036. char *</span>
  3041. <span id="line3037">3037. makesingular(const char *oldstr)</span>
  3042. <span id="line3038">3038. {</span>
  3043. <span id="line3039">3039. char *p, *bp;</span>
  3044. <span id="line3040">3040. const char *excess = 0;</span>
  3045. <span id="line3041">3041. char *str = nextobuf();</span>
  3046. <span id="line3042">3042. </span>
  3047. <span id="line3043">3043. if (oldstr)</span>
  3048. <span id="line3044">3044. while (*oldstr == ' ')</span>
  3049. <span id="line3045">3045. oldstr++;</span>
  3050. <span id="line3046">3046. if (!oldstr || !*oldstr) {</span>
  3051. <span id="line3047">3047. impossible("singular of null?");</span>
  3052. <span id="line3048">3048. str[0] = '\0';</span>
  3053. <span id="line3049">3049. return str;</span>
  3054. <span id="line3050">3050. }</span>
  3055. <span id="line3051">3051. /* makeplural() of pronouns isn't reversible but at least we can</span>
  3056. <span id="line3052">3052. force a singular value */</span>
  3057. <span id="line3053">3053. *str = '\0';</span>
  3058. <span id="line3054">3054. if (!strcmpi(genders[3].he, oldstr)) /* "they" */</span>
  3059. <span id="line3055">3055. Strcpy(str, genders[2].he); /* "it" */</span>
  3060. <span id="line3056">3056. else if (!strcmpi(genders[3].him, oldstr)) /* "them" */</span>
  3061. <span id="line3057">3057. Strcpy(str, genders[2].him); /* also "it" */</span>
  3062. <span id="line3058">3058. else if (!strcmpi(genders[3].his, oldstr)) /* "their" */</span>
  3063. <span id="line3059">3059. Strcpy(str, genders[2].his); /* "its" */</span>
  3064. <span id="line3060">3060. if (*str) {</span>
  3065. <span id="line3061">3061. if (oldstr[0] == highc(oldstr[0]))</span>
  3066. <span id="line3062">3062. str[0] = highc(str[0]);</span>
  3067. <span id="line3063">3063. return str;</span>
  3068. <span id="line3064">3064. }</span>
  3069. <span id="line3065">3065. </span>
  3070. <span id="line3066">3066. bp = strcpy(str, oldstr);</span>
  3071. <span id="line3067">3067. </span>
  3072. <span id="line3068">3068. /* check for "foo of bar" so that we can focus on "foo" */</span>
  3073. <span id="line3069">3069. if ((p = singplur_compound(bp)) != 0) {</span>
  3074. <span id="line3070">3070. excess = oldstr + (int) (p - bp);</span>
  3075. <span id="line3071">3071. *p = '\0';</span>
  3076. <span id="line3072">3072. } else</span>
  3077. <span id="line3073">3073. p = eos(bp);</span>
  3078. <span id="line3074">3074. </span>
  3079. <span id="line3075">3075. /* dispense with some words which don't need singularization */</span>
  3080. <span id="line3076">3076. if (singplur_lookup(bp, p, FALSE, special_subjs))</span>
  3081. <span id="line3077">3077. goto bottom;</span>
  3082. <span id="line3078">3078. </span>
  3083. <span id="line3079">3079. /* remove -s or -es (boxes) or -ies (rubies) */</span>
  3084. <span id="line3080">3080. if (p >= bp + 1 && lowc(p[-1]) == 's') {</span>
  3085. <span id="line3081">3081. if (p >= bp + 2 && lowc(p[-2]) == 'e') {</span>
  3086. <span id="line3082">3082. if (p >= bp + 3 && lowc(p[-3]) == 'i') { /* "ies" */</span>
  3087. <span id="line3083">3083. if (!BSTRCMPI(bp, p - 7, "cookies")</span>
  3088. <span id="line3084">3084. || (!BSTRCMPI(bp, p - 4, "pies")</span>
  3089. <span id="line3085">3085. /* avoid false match for "harpies" */</span>
  3090. <span id="line3086">3086. && (p - 4 == bp || p[-5] == ' '))</span>
  3091. <span id="line3087">3087. /* alternate djinni/djinn spelling; not really needed */</span>
  3092. <span id="line3088">3088. || (!BSTRCMPI(bp, p - 6, "genies")</span>
  3093. <span id="line3089">3089. /* avoid false match for "progenies" */</span>
  3094. <span id="line3090">3090. && (p - 6 == bp || p[-7] == ' '))</span>
  3095. <span id="line3091">3091. || !BSTRCMPI(bp, p - 5, "mbies") /* zombie */</span>
  3096. <span id="line3092">3092. || !BSTRCMPI(bp, p - 5, "yries")) /* valkyrie */</span>
  3097. <span id="line3093">3093. goto mins;</span>
  3098. <span id="line3094">3094. Strcasecpy(p - 3, "y"); /* ies -> y */</span>
  3099. <span id="line3095">3095. goto bottom;</span>
  3100. <span id="line3096">3096. }</span>
  3101. <span id="line3097">3097. /* wolves, but f to ves isn't fully reversible */</span>
  3102. <span id="line3098">3098. if (p - 4 >= bp && (strchr("lr", lowc(*(p - 4)))</span>
  3103. <span id="line3099">3099. || strchr(vowels, lowc(*(p - 4))))</span>
  3104. <span id="line3100">3100. && !BSTRCMPI(bp, p - 3, "ves")) {</span>
  3105. <span id="line3101">3101. if (!BSTRCMPI(bp, p - 6, "cloves")</span>
  3106. <span id="line3102">3102. || !BSTRCMPI(bp, p - 6, "nerves"))</span>
  3107. <span id="line3103">3103. goto mins;</span>
  3108. <span id="line3104">3104. Strcasecpy(p - 3, "f"); /* ves -> f */</span>
  3109. <span id="line3105">3105. goto bottom;</span>
  3110. <span id="line3106">3106. }</span>
  3111. <span id="line3107">3107. /* note: nurses, axes but boxes, wumpuses */</span>
  3112. <span id="line3108">3108. if (!BSTRCMPI(bp, p - 4, "eses")</span>
  3113. <span id="line3109">3109. || !BSTRCMPI(bp, p - 4, "oxes") /* boxes, foxes */</span>
  3114. <span id="line3110">3110. || !BSTRCMPI(bp, p - 4, "nxes") /* lynxes */</span>
  3115. <span id="line3111">3111. || !BSTRCMPI(bp, p - 4, "ches")</span>
  3116. <span id="line3112">3112. || !BSTRCMPI(bp, p - 4, "uses") /* lotuses */</span>
  3117. <span id="line3113">3113. || !BSTRCMPI(bp, p - 4, "shes") /* splashes [of venom] */</span>
  3118. <span id="line3114">3114. || !BSTRCMPI(bp, p - 4, "sses") /* priestesses */</span>
  3119. <span id="line3115">3115. || !BSTRCMPI(bp, p - 5, "atoes") /* tomatoes */</span>
  3120. <span id="line3116">3116. || !BSTRCMPI(bp, p - 7, "dingoes")</span>
  3121. <span id="line3117">3117. || !BSTRCMPI(bp, p - 7, "Aleaxes")) {</span>
  3122. <span id="line3118">3118. *(p - 2) = '\0'; /* drop es */</span>
  3123. <span id="line3119">3119. goto bottom;</span>
  3124. <span id="line3120">3120. } /* else fall through to mins */</span>
  3125. <span id="line3121">3121. </span>
  3126. <span id="line3122">3122. /* ends in 's' but not 'es' */</span>
  3127. <span id="line3123">3123. } else if (!BSTRCMPI(bp, p - 2, "us")) { /* lotus, fungus... */</span>
  3128. <span id="line3124">3124. if (BSTRCMPI(bp, p - 6, "tengus") /* but not these... */</span>
  3129. <span id="line3125">3125. && BSTRCMPI(bp, p - 7, "hezrous"))</span>
  3130. <span id="line3126">3126. goto bottom;</span>
  3131. <span id="line3127">3127. } else if (!BSTRCMPI(bp, p - 2, "ss")</span>
  3132. <span id="line3128">3128. || !BSTRCMPI(bp, p - 5, " lens")</span>
  3133. <span id="line3129">3129. || (p - 4 == bp && !strcmpi(p - 4, "lens"))) {</span>
  3134. <span id="line3130">3130. goto bottom;</span>
  3135. <span id="line3131">3131. }</span>
  3136. <span id="line3132">3132. mins:</span>
  3137. <span id="line3133">3133. *(p - 1) = '\0'; /* drop s */</span>
  3138. <span id="line3134">3134. </span>
  3139. <span id="line3135">3135. } else { /* input doesn't end in 's' */</span>
  3140. <span id="line3136">3136. </span>
  3141. <span id="line3137">3137. if (!BSTRCMPI(bp, p - 3, "men")</span>
  3142. <span id="line3138">3138. && !badman(bp, FALSE)) {</span>
  3143. <span id="line3139">3139. Strcasecpy(p - 2, "an");</span>
  3144. <span id="line3140">3140. goto bottom;</span>
  3145. <span id="line3141">3141. }</span>
  3146. <span id="line3142">3142. /* matzot -> matzo, algae -> alga */</span>
  3147. <span id="line3143">3143. if (!BSTRCMPI(bp, p - 6, "matzot") || !BSTRCMPI(bp, p - 2, "ae")</span>
  3148. <span id="line3144">3144. || !BSTRCMPI(bp, p - 4, "eaux")) {</span>
  3149. <span id="line3145">3145. *(p - 1) = '\0'; /* drop t/e/x */</span>
  3150. <span id="line3146">3146. goto bottom;</span>
  3151. <span id="line3147">3147. }</span>
  3152. <span id="line3148">3148. /* balactheria -> balactherium */</span>
  3153. <span id="line3149">3149. if (p - 4 >= bp && !strcmpi(p - 2, "ia")</span>
  3154. <span id="line3150">3150. && strchr("lr", lowc(*(p - 3))) && lowc(*(p - 4)) == 'e') {</span>
  3155. <span id="line3151">3151. Strcasecpy(p - 1, "um"); /* a -> um */</span>
  3156. <span id="line3152">3152. }</span>
  3157. <span id="line3153">3153. </span>
  3158. <span id="line3154">3154. /* here we cannot find the plural suffix */</span>
  3159. <span id="line3155">3155. }</span>
  3160. <span id="line3156">3156. </span>
  3161. <span id="line3157">3157. bottom:</span>
  3162. <span id="line3158">3158. /* if we stripped off a suffix (" of bar" from "foo of bar"),</span>
  3163. <span id="line3159">3159. put it back now [strcat() isn't actually 100% safe here...] */</span>
  3164. <span id="line3160">3160. if (excess)</span>
  3165. <span id="line3161">3161. Strcat(bp, excess);</span>
  3166. <span id="line3162">3162. </span>
  3167. <span id="line3163">3163. return bp;</span>
  3168. <span id="line3164">3164. }</span>
  3169. <span id="line3165">3165. </span>
  3170. <span id="line3166">3166. </span>
  3171. <span id="line3167">3167. staticfn boolean</span>
  3172. <span id="line3168">3168. ch_ksound(const char *basestr)</span>
  3173. <span id="line3169">3169. {</span>
  3174. <span id="line3170">3170. /* these are some *ch words/suffixes that make a k-sound. They pluralize by</span>
  3175. <span id="line3171">3171. adding 's' rather than 'es' */</span>
  3176. <span id="line3172">3172. static const char *const ch_k[] = {</span>
  3177. <span id="line3173">3173. "monarch", "poch", "tech", "mech", "stomach", "psych",</span>
  3178. <span id="line3174">3174. "amphibrach", "anarch", "atriarch", "azedarach", "broch",</span>
  3179. <span id="line3175">3175. "gastrotrich", "isopach", "loch", "oligarch", "peritrich",</span>
  3180. <span id="line3176">3176. "sandarach", "sumach", "symposiarch",</span>
  3181. <span id="line3177">3177. };</span>
  3182. <span id="line3178">3178. int i, al;</span>
  3183. <span id="line3179">3179. const char *endstr;</span>
  3184. <span id="line3180">3180. </span>
  3185. <span id="line3181">3181. if (!basestr || strlen(basestr) < 4)</span>
  3186. <span id="line3182">3182. return FALSE;</span>
  3187. <span id="line3183">3183. </span>
  3188. <span id="line3184">3184. endstr = eos((char *) basestr);</span>
  3189. <span id="line3185">3185. for (i = 0; i < SIZE(ch_k); i++) {</span>
  3190. <span id="line3186">3186. al = (int) strlen(ch_k[i]);</span>
  3191. <span id="line3187">3187. if (!BSTRCMPI(basestr, endstr - al, ch_k[i]))</span>
  3192. <span id="line3188">3188. return TRUE;</span>
  3193. <span id="line3189">3189. }</span>
  3194. <span id="line3190">3190. return FALSE;</span>
  3195. <span id="line3191">3191. }</span>
  3196. <span id="line3192">3192. </span>
  3197. <span id="line3193">3193. staticfn boolean</span>
  3198. <span id="line3194">3194. badman(</span>
  3199. <span id="line3195">3195. const char *basestr,</span>
  3200. <span id="line3196">3196. boolean to_plural) /* True: makeplural, False: makesingular */</span>
  3201. <span id="line3197">3197. {</span>
  3202. <span id="line3198">3198. /* these are all the prefixes for *man that don't have a *men plural */</span>
  3203. <span id="line3199">3199. static const char *const no_men[] = {</span>
  3204. <span id="line3200">3200. "albu", "antihu", "anti", "ata", "auto", "bildungsro", "cai", "cay",</span>
  3205. <span id="line3201">3201. "ceru", "corner", "decu", "des", "dura", "fir", "hanu", "het",</span>
  3206. <span id="line3202">3202. "infrahu", "inhu", "nonhu", "otto", "out", "prehu", "protohu",</span>
  3207. <span id="line3203">3203. "subhu", "superhu", "talis", "unhu", "sha",</span>
  3208. <span id="line3204">3204. "hu", "un", "le", "re", "so", "to", "at", "a",</span>
  3209. <span id="line3205">3205. };</span>
  3210. <span id="line3206">3206. /* these are all the prefixes for *men that don't have a *man singular */</span>
  3211. <span id="line3207">3207. static const char *const no_man[] = {</span>
  3212. <span id="line3208">3208. "abdo", "acu", "agno", "ceru", "cogno", "cycla", "fleh", "grava",</span>
  3213. <span id="line3209">3209. "hegu", "preno", "sonar", "speci", "dai", "exa", "fla", "sta", "teg",</span>
  3214. <span id="line3210">3210. "tegu", "vela", "da", "hy", "lu", "no", "nu", "ra", "ru", "se", "vi",</span>
  3215. <span id="line3211">3211. "ya", "o", "a",</span>
  3216. <span id="line3212">3212. };</span>
  3217. <span id="line3213">3213. int i, al;</span>
  3218. <span id="line3214">3214. const char *endstr, *spot;</span>
  3219. <span id="line3215">3215. </span>
  3220. <span id="line3216">3216. if (!basestr || strlen(basestr) < 4)</span>
  3221. <span id="line3217">3217. return FALSE;</span>
  3222. <span id="line3218">3218. </span>
  3223. <span id="line3219">3219. endstr = eos((char *) basestr);</span>
  3224. <span id="line3220">3220. </span>
  3225. <span id="line3221">3221. if (to_plural) {</span>
  3226. <span id="line3222">3222. for (i = 0; i < SIZE(no_men); i++) {</span>
  3227. <span id="line3223">3223. al = (int) strlen(no_men[i]);</span>
  3228. <span id="line3224">3224. spot = endstr - (al + 3);</span>
  3229. <span id="line3225">3225. if (!BSTRNCMPI(basestr, spot, no_men[i], al)</span>
  3230. <span id="line3226">3226. && (spot == basestr || *(spot - 1) == ' '))</span>
  3231. <span id="line3227">3227. return TRUE;</span>
  3232. <span id="line3228">3228. }</span>
  3233. <span id="line3229">3229. } else {</span>
  3234. <span id="line3230">3230. for (i = 0; i < SIZE(no_man); i++) {</span>
  3235. <span id="line3231">3231. al = (int) strlen(no_man[i]);</span>
  3236. <span id="line3232">3232. spot = endstr - (al + 3);</span>
  3237. <span id="line3233">3233. if (!BSTRNCMPI(basestr, spot, no_man[i], al)</span>
  3238. <span id="line3234">3234. && (spot == basestr || *(spot - 1) == ' '))</span>
  3239. <span id="line3235">3235. return TRUE;</span>
  3240. <span id="line3236">3236. }</span>
  3241. <span id="line3237">3237. }</span>
  3242. <span id="line3238">3238. return FALSE;</span>
  3243. <span id="line3239">3239. }</span>
  3244. <span id="line3240">3240. </span>
  3245. <span id="line3241">3241. /* compare user string against object name string using fuzzy matching */</span>
  3246. <span id="line3242">3242. staticfn boolean</span>
  3247. <span id="line3243">3243. wishymatch(</span>
  3248. <span id="line3244">3244. const char *u_str, /* from user, so might be variant spelling */</span>
  3249. <span id="line3245">3245. const char *o_str, /* from objects[], so is in canonical form */</span>
  3250. <span id="line3246">3246. boolean retry_inverted) /* optional extra "of" handling */</span>
  3251. <span id="line3247">3247. {</span>
  3252. <span id="line3248">3248. static NEARDATA const char detect_SP[] = "detect ",</span>
  3253. <span id="line3249">3249. SP_detection[] = " detection";</span>
  3254. <span id="line3250">3250. char *p, buf[BUFSZ];</span>
  3255. <span id="line3251">3251. </span>
  3256. <span id="line3252">3252. /* ignore spaces & hyphens and upper/lower case when comparing */</span>
  3257. <span id="line3253">3253. if (fuzzymatch(u_str, o_str, " -", TRUE))</span>
  3258. <span id="line3254">3254. return TRUE;</span>
  3259. <span id="line3255">3255. </span>
  3260. <span id="line3256">3256. if (retry_inverted) {</span>
  3261. <span id="line3257">3257. const char *u_of, *o_of;</span>
  3262. <span id="line3258">3258. </span>
  3263. <span id="line3259">3259. /* when just one of the strings is in the form "foo of bar",</span>
  3264. <span id="line3260">3260. convert it into "bar foo" and perform another comparison */</span>
  3265. <span id="line3261">3261. u_of = strstri(u_str, " of ");</span>
  3266. <span id="line3262">3262. o_of = strstri(o_str, " of ");</span>
  3267. <span id="line3263">3263. if (u_of && !o_of) {</span>
  3268. <span id="line3264">3264. Strcpy(buf, u_of + 4);</span>
  3269. <span id="line3265">3265. copynchars(eos(strcat(buf, " ")), u_str, (int) (u_of - u_str));</span>
  3270. <span id="line3266">3266. if (fuzzymatch(buf, o_str, " -", TRUE))</span>
  3271. <span id="line3267">3267. return TRUE;</span>
  3272. <span id="line3268">3268. } else if (o_of && !u_of) {</span>
  3273. <span id="line3269">3269. Strcpy(buf, o_of + 4);</span>
  3274. <span id="line3270">3270. copynchars(eos(strcat(buf, " ")), o_str, (int) (o_of - o_str));</span>
  3275. <span id="line3271">3271. if (fuzzymatch(u_str, buf, " -", TRUE))</span>
  3276. <span id="line3272">3272. return TRUE;</span>
  3277. <span id="line3273">3273. }</span>
  3278. <span id="line3274">3274. }</span>
  3279. <span id="line3275">3275. </span>
  3280. <span id="line3276">3276. /* [note: if something like "elven speed boots" ever gets added, these</span>
  3281. <span id="line3277">3277. special cases should be changed to call wishymatch() recursively in</span>
  3282. <span id="line3278">3278. order to get the "of" inversion handling] */</span>
  3283. <span id="line3279">3279. if (!strncmp(o_str, "dwarvish ", 9)) {</span>
  3284. <span id="line3280">3280. if (!strncmpi(u_str, "dwarven ", 8))</span>
  3285. <span id="line3281">3281. return fuzzymatch(u_str + 8, o_str + 9, " -", TRUE);</span>
  3286. <span id="line3282">3282. } else if (!strncmp(o_str, "elven ", 6)) {</span>
  3287. <span id="line3283">3283. if (!strncmpi(u_str, "elvish ", 7))</span>
  3288. <span id="line3284">3284. return fuzzymatch(u_str + 7, o_str + 6, " -", TRUE);</span>
  3289. <span id="line3285">3285. else if (!strncmpi(u_str, "elfin ", 6))</span>
  3290. <span id="line3286">3286. return fuzzymatch(u_str + 6, o_str + 6, " -", TRUE);</span>
  3291. <span id="line3287">3287. } else if (strstri(o_str, "helm") && strstri(u_str, "helmet")) {</span>
  3292. <span id="line3288">3288. copynchars(buf, u_str, (int) sizeof buf - 1);</span>
  3293. <span id="line3289">3289. (void) strsubst(buf, "helmet", "helm");</span>
  3294. <span id="line3290">3290. return wishymatch(buf, o_str, TRUE);</span>
  3295. <span id="line3291">3291. } else if (strstri(o_str, "gauntlets") && strstri(u_str, "gloves")) {</span>
  3296. <span id="line3292">3292. /* -3: room to replace shorter "gloves" with longer "gauntlets" */</span>
  3297. <span id="line3293">3293. copynchars(buf, u_str, (int) sizeof buf - 1 - 3);</span>
  3298. <span id="line3294">3294. (void) strsubst(buf, "gloves", "gauntlets");</span>
  3299. <span id="line3295">3295. return wishymatch(buf, o_str, TRUE);</span>
  3300. <span id="line3296">3296. } else if (!strncmp(o_str, detect_SP, sizeof detect_SP - 1)) {</span>
  3301. <span id="line3297">3297. /* check for "detect <foo>" vs "<foo> detection" */</span>
  3302. <span id="line3298">3298. if ((p = strstri(u_str, SP_detection)) != 0</span>
  3303. <span id="line3299">3299. && !*(p + sizeof SP_detection - 1)) {</span>
  3304. <span id="line3300">3300. /* convert "<foo> detection" into "detect <foo>" */</span>
  3305. <span id="line3301">3301. *p = '\0';</span>
  3306. <span id="line3302">3302. Strcat(strcpy(buf, detect_SP), u_str);</span>
  3307. <span id="line3303">3303. /* "detect monster" -> "detect monsters" */</span>
  3308. <span id="line3304">3304. if (!strcmpi(u_str, "monster"))</span>
  3309. <span id="line3305">3305. Strcat(buf, "s");</span>
  3310. <span id="line3306">3306. *p = ' ';</span>
  3311. <span id="line3307">3307. return fuzzymatch(buf, o_str, " -", TRUE);</span>
  3312. <span id="line3308">3308. }</span>
  3313. <span id="line3309">3309. } else if (strstri(o_str, SP_detection)) {</span>
  3314. <span id="line3310">3310. /* and the inverse, "<foo> detection" vs "detect <foo>" */</span>
  3315. <span id="line3311">3311. if (!strncmpi(u_str, detect_SP, sizeof detect_SP - 1)) {</span>
  3316. <span id="line3312">3312. /* convert "detect <foo>s" into "<foo> detection" */</span>
  3317. <span id="line3313">3313. p = makesingular(u_str + sizeof detect_SP - 1);</span>
  3318. <span id="line3314">3314. Strcat(strcpy(buf, p), SP_detection);</span>
  3319. <span id="line3315">3315. /* caller may be looping through objects[], so avoid</span>
  3320. <span id="line3316">3316. churning through all the obufs */</span>
  3321. <span id="line3317">3317. releaseobuf(p);</span>
  3322. <span id="line3318">3318. return fuzzymatch(buf, o_str, " -", TRUE);</span>
  3323. <span id="line3319">3319. }</span>
  3324. <span id="line3320">3320. } else if (strstri(o_str, "ability")) {</span>
  3325. <span id="line3321">3321. /* when presented with "foo of bar", makesingular() used to</span>
  3326. <span id="line3322">3322. singularize both foo & bar, but now only does so for foo */</span>
  3327. <span id="line3323">3323. /* catch "{potion(s),ring} of {gain,restore,sustain} abilities" */</span>
  3328. <span id="line3324">3324. if ((p = strstri(u_str, "abilities")) != 0</span>
  3329. <span id="line3325">3325. && !*(p + sizeof "abilities" - 1)) {</span>
  3330. <span id="line3326">3326. (void) strncpy(buf, u_str, (unsigned) (p - u_str));</span>
  3331. <span id="line3327">3327. Strcpy(buf + (p - u_str), "ability");</span>
  3332. <span id="line3328">3328. return fuzzymatch(buf, o_str, " -", TRUE);</span>
  3333. <span id="line3329">3329. }</span>
  3334. <span id="line3330">3330. } else if (!strcmp(o_str, "aluminum")) {</span>
  3335. <span id="line3331">3331. /* this special case doesn't really fit anywhere else... */</span>
  3336. <span id="line3332">3332. /* (note that " wand" will have been stripped off by now) */</span>
  3337. <span id="line3333">3333. if (!strcmpi(u_str, "aluminium"))</span>
  3338. <span id="line3334">3334. return fuzzymatch(u_str + 9, o_str + 8, " -", TRUE);</span>
  3339. <span id="line3335">3335. }</span>
  3340. <span id="line3336">3336. </span>
  3341. <span id="line3337">3337. return FALSE;</span>
  3342. <span id="line3338">3338. }</span>
  3343. <span id="line3339">3339. </span>
  3344. <span id="line3340">3340. struct o_range {</span>
  3345. <span id="line3341">3341. const char *name, oclass;</span>
  3346. <span id="line3342">3342. int f_o_range, l_o_range;</span>
  3347. <span id="line3343">3343. };</span>
  3348. <span id="line3344">3344. </span>
  3349. <span id="line3345">3345. /* wishable subranges of objects */</span>
  3350. <span id="line3346">3346. static NEARDATA const struct o_range o_ranges[] = {</span>
  3351. <span id="line3347">3347. { "bag", TOOL_CLASS, SACK, BAG_OF_TRICKS },</span>
  3352. <span id="line3348">3348. { "lamp", TOOL_CLASS, OIL_LAMP, MAGIC_LAMP },</span>
  3353. <span id="line3349">3349. { "candle", TOOL_CLASS, TALLOW_CANDLE, WAX_CANDLE },</span>
  3354. <span id="line3350">3350. { "horn", TOOL_CLASS, TOOLED_HORN, HORN_OF_PLENTY },</span>
  3355. <span id="line3351">3351. { "shield", ARMOR_CLASS, SMALL_SHIELD, SHIELD_OF_REFLECTION },</span>
  3356. <span id="line3352">3352. { "hat", ARMOR_CLASS, FEDORA, DUNCE_CAP },</span>
  3357. <span id="line3353">3353. { "helm", ARMOR_CLASS, ELVEN_LEATHER_HELM, HELM_OF_TELEPATHY },</span>
  3358. <span id="line3354">3354. { "gloves", ARMOR_CLASS, LEATHER_GLOVES, GAUNTLETS_OF_DEXTERITY },</span>
  3359. <span id="line3355">3355. { "gauntlets", ARMOR_CLASS, LEATHER_GLOVES, GAUNTLETS_OF_DEXTERITY },</span>
  3360. <span id="line3356">3356. { "boots", ARMOR_CLASS, LOW_BOOTS, LEVITATION_BOOTS },</span>
  3361. <span id="line3357">3357. { "shoes", ARMOR_CLASS, LOW_BOOTS, IRON_SHOES },</span>
  3362. <span id="line3358">3358. { "cloak", ARMOR_CLASS, MUMMY_WRAPPING, CLOAK_OF_DISPLACEMENT },</span>
  3363. <span id="line3359">3359. { "shirt", ARMOR_CLASS, HAWAIIAN_SHIRT, T_SHIRT },</span>
  3364. <span id="line3360">3360. { "dragon scales", ARMOR_CLASS, GRAY_DRAGON_SCALES,</span>
  3365. <span id="line3361">3361. YELLOW_DRAGON_SCALES },</span>
  3366. <span id="line3362">3362. { "dragon scale mail", ARMOR_CLASS, GRAY_DRAGON_SCALE_MAIL,</span>
  3367. <span id="line3363">3363. YELLOW_DRAGON_SCALE_MAIL },</span>
  3368. <span id="line3364">3364. { "sword", WEAPON_CLASS, SHORT_SWORD, KATANA },</span>
  3369. <span id="line3365">3365. { "venom", VENOM_CLASS, BLINDING_VENOM, ACID_VENOM },</span>
  3370. <span id="line3366">3366. { "gray stone", GEM_CLASS, LUCKSTONE, FLINT },</span>
  3371. <span id="line3367">3367. { "grey stone", GEM_CLASS, LUCKSTONE, FLINT },</span>
  3372. <span id="line3368">3368. };</span>
  3373. <span id="line3369">3369. </span>
  3374. <span id="line3370">3370. /* alternate spellings; if the difference is only the presence or</span>
  3375. <span id="line3371">3371. absence of spaces and/or hyphens (such as "pickaxe" vs "pick axe"</span>
  3376. <span id="line3372">3372. vs "pick-axe") then there is no need for inclusion in this list;</span>
  3377. <span id="line3373">3373. likewise for ``"of" inversions'' ("boots of speed" vs "speed boots") */</span>
  3378. <span id="line3374">3374. static const struct alt_spellings {</span>
  3379. <span id="line3375">3375. const char *sp;</span>
  3380. <span id="line3376">3376. int ob;</span>
  3381. <span id="line3377">3377. } spellings[] = {</span>
  3382. <span id="line3378">3378. { "pickax", PICK_AXE },</span>
  3383. <span id="line3379">3379. { "whip", BULLWHIP },</span>
  3384. <span id="line3380">3380. { "saber", SILVER_SABER },</span>
  3385. <span id="line3381">3381. { "silver sabre", SILVER_SABER },</span>
  3386. <span id="line3382">3382. { "smooth shield", SHIELD_OF_REFLECTION },</span>
  3387. <span id="line3383">3383. { "grey dragon scale mail", GRAY_DRAGON_SCALE_MAIL },</span>
  3388. <span id="line3384">3384. { "grey dragon scales", GRAY_DRAGON_SCALES },</span>
  3389. <span id="line3385">3385. { "iron ball", HEAVY_IRON_BALL },</span>
  3390. <span id="line3386">3386. { "lantern", BRASS_LANTERN },</span>
  3391. <span id="line3387">3387. { "mattock", DWARVISH_MATTOCK },</span>
  3392. <span id="line3388">3388. { "amulet of poison resistance", AMULET_VERSUS_POISON },</span>
  3393. <span id="line3389">3389. { "amulet of protection", AMULET_OF_GUARDING },</span>
  3394. <span id="line3390">3390. { "amulet of telepathy", AMULET_OF_ESP },</span>
  3395. <span id="line3391">3391. { "helm of esp", HELM_OF_TELEPATHY },</span>
  3396. <span id="line3392">3392. { "gauntlets of ogre power", GAUNTLETS_OF_POWER },</span>
  3397. <span id="line3393">3393. { "gauntlets of giant strength", GAUNTLETS_OF_POWER },</span>
  3398. <span id="line3394">3394. { "elven chain mail", ELVEN_MITHRIL_COAT },</span>
  3399. <span id="line3395">3395. { "silver shield", SHIELD_OF_REFLECTION },</span>
  3400. <span id="line3396">3396. { "potion of sleep", POT_SLEEPING },</span>
  3401. <span id="line3397">3397. { "scroll of recharging", SCR_CHARGING },</span>
  3402. <span id="line3398">3398. { "recharging", SCR_CHARGING },</span>
  3403. <span id="line3399">3399. { "stone", ROCK },</span>
  3404. <span id="line3400">3400. { "camera", EXPENSIVE_CAMERA },</span>
  3405. <span id="line3401">3401. { "tee shirt", T_SHIRT },</span>
  3406. <span id="line3402">3402. { "can", TIN },</span>
  3407. <span id="line3403">3403. { "can opener", TIN_OPENER },</span>
  3408. <span id="line3404">3404. { "kelp", KELP_FROND },</span>
  3409. <span id="line3405">3405. { "eucalyptus", EUCALYPTUS_LEAF },</span>
  3410. <span id="line3406">3406. { "lembas", LEMBAS_WAFER },</span>
  3411. <span id="line3407">3407. { "tripe", TRIPE_RATION },</span>
  3412. <span id="line3408">3408. { "cookie", FORTUNE_COOKIE },</span>
  3413. <span id="line3409">3409. { "pie", CREAM_PIE },</span>
  3414. <span id="line3410">3410. { "huge meatball", ENORMOUS_MEATBALL }, /* likely conflated name */</span>
  3415. <span id="line3411">3411. { "huge chunk of meat", ENORMOUS_MEATBALL }, /* original name */</span>
  3416. <span id="line3412">3412. { "marker", MAGIC_MARKER },</span>
  3417. <span id="line3413">3413. { "hook", GRAPPLING_HOOK },</span>
  3418. <span id="line3414">3414. { "grappling iron", GRAPPLING_HOOK },</span>
  3419. <span id="line3415">3415. { "grapnel", GRAPPLING_HOOK },</span>
  3420. <span id="line3416">3416. { "grapple", GRAPPLING_HOOK },</span>
  3421. <span id="line3417">3417. { "protection from shape shifters", RIN_PROTECTION_FROM_SHAPE_CHAN },</span>
  3422. <span id="line3418">3418. { "accuracy", RIN_INCREASE_ACCURACY },</span>
  3423. <span id="line3419">3419. /* if we ever add other sizes, move this to o_ranges[] with "bag" */</span>
  3424. <span id="line3420">3420. { "box", LARGE_BOX },</span>
  3425. <span id="line3421">3421. /* normally we wouldn't have to worry about unnecessary <space>, but</span>
  3426. <span id="line3422">3422. " stone" will get stripped off, preventing a wishymatch; that actually</span>
  3427. <span id="line3423">3423. lets "flint stone" be a match, so we also accept bogus "flintstone" */</span>
  3428. <span id="line3424">3424. { "luck stone", LUCKSTONE },</span>
  3429. <span id="line3425">3425. { "load stone", LOADSTONE },</span>
  3430. <span id="line3426">3426. { "touch stone", TOUCHSTONE },</span>
  3431. <span id="line3427">3427. { "flintstone", FLINT },</span>
  3432. <span id="line3428">3428. { (const char *) 0, 0 },</span>
  3433. <span id="line3429">3429. };</span>
  3434. <span id="line3430">3430. </span>
  3435. <span id="line3431">3431. staticfn short</span>
  3436. <span id="line3432">3432. rnd_otyp_by_wpnskill(schar skill)</span>
  3437. <span id="line3433">3433. {</span>
  3438. <span id="line3434">3434. int i, n = 0;</span>
  3439. <span id="line3435">3435. short otyp = STRANGE_OBJECT;</span>
  3440. <span id="line3436">3436. </span>
  3441. <span id="line3437">3437. for (i = svb.bases[WEAPON_CLASS];</span>
  3442. <span id="line3438">3438. i < NUM_OBJECTS && objects[i].oc_class == WEAPON_CLASS; i++)</span>
  3443. <span id="line3439">3439. if (objects[i].oc_skill == skill) {</span>
  3444. <span id="line3440">3440. n++;</span>
  3445. <span id="line3441">3441. otyp = i;</span>
  3446. <span id="line3442">3442. }</span>
  3447. <span id="line3443">3443. if (n > 0) {</span>
  3448. <span id="line3444">3444. n = rn2(n);</span>
  3449. <span id="line3445">3445. for (i = svb.bases[WEAPON_CLASS];</span>
  3450. <span id="line3446">3446. i < NUM_OBJECTS && objects[i].oc_class == WEAPON_CLASS; i++)</span>
  3451. <span id="line3447">3447. if (objects[i].oc_skill == skill)</span>
  3452. <span id="line3448">3448. if (--n < 0)</span>
  3453. <span id="line3449">3449. return i;</span>
  3454. <span id="line3450">3450. }</span>
  3455. <span id="line3451">3451. return otyp;</span>
  3456. <span id="line3452">3452. }</span>
  3457. <span id="line3453">3453. </span>
  3458. <span id="line3454">3454. staticfn short</span>
  3459. <span id="line3455">3455. rnd_otyp_by_namedesc(</span>
  3460. <span id="line3456">3456. const char *name,</span>
  3461. <span id="line3457">3457. char oclass,</span>
  3462. <span id="line3458">3458. int xtra_prob) /* add to item's chance of being chosen; non-zero causes</span>
  3463. <span id="line3459">3459. * 0% random generation items to also be considered */</span>
  3464. <span id="line3460">3460. {</span>
  3465. <span id="line3461">3461. int i, n = 0;</span>
  3466. <span id="line3462">3462. short validobjs[NUM_OBJECTS];</span>
  3467. <span id="line3463">3463. const char *zn, *of;</span>
  3468. <span id="line3464">3464. boolean check_of;</span>
  3469. <span id="line3465">3465. int lo, hi, minglob, maxglob, prob, maxprob = 0;</span>
  3470. <span id="line3466">3466. </span>
  3471. <span id="line3467">3467. if (!name || !*name)</span>
  3472. <span id="line3468">3468. return STRANGE_OBJECT;</span>
  3473. <span id="line3469">3469. </span>
  3474. <span id="line3470">3470. /* only skip "foo of" for "foo of bar" if target doesn't contain " of " */</span>
  3475. <span id="line3471">3471. check_of = (strstri(name, " of ") == 0);</span>
  3476. <span id="line3472">3472. minglob = GLOB_OF_GRAY_OOZE;</span>
  3477. <span id="line3473">3473. maxglob = GLOB_OF_BLACK_PUDDING;</span>
  3478. <span id="line3474">3474. </span>
  3479. <span id="line3475">3475. (void) memset((genericptr_t) validobjs, 0, sizeof validobjs);</span>
  3480. <span id="line3476">3476. if (oclass) {</span>
  3481. <span id="line3477">3477. lo = svb.bases[(uchar) oclass];</span>
  3482. <span id="line3478">3478. hi = svb.bases[(uchar) oclass + 1] - 1;</span>
  3483. <span id="line3479">3479. } else {</span>
  3484. <span id="line3480">3480. lo = MAXOCLASSES; /* STRANGE_OBJECT + 1; */</span>
  3485. <span id="line3481">3481. hi = NUM_OBJECTS - 1;</span>
  3486. <span id="line3482">3482. }</span>
  3487. <span id="line3483">3483. /* FIXME:</span>
  3488. <span id="line3484">3484. * When this spans classes (the !oclass case), the item</span>
  3489. <span id="line3485">3485. * probabilities are not very useful because they don't take</span>
  3490. <span id="line3486">3486. * the class generation probability into account. [If 10%</span>
  3491. <span id="line3487">3487. * of spellbooks were blank and 1% of scrolls were blank,</span>
  3492. <span id="line3488">3488. * "blank" would have 10/11 chance to yield a book even though</span>
  3493. <span id="line3489">3489. * scrolls are supposed to be much more common than books.]</span>
  3494. <span id="line3490">3490. */</span>
  3495. <span id="line3491">3491. for (i = lo; i <= hi; ++i) {</span>
  3496. <span id="line3492">3492. /* don't match extra descriptions (w/o real name) */</span>
  3497. <span id="line3493">3493. if ((zn = OBJ_NAME(objects[i])) == 0)</span>
  3498. <span id="line3494">3494. continue;</span>
  3499. <span id="line3495">3495. if (wishymatch(name, zn, TRUE) /* objects[] name */</span>
  3500. <span id="line3496">3496. /* let "<bar>" match "<foo> of <bar>" (already does if foo is</span>
  3501. <span id="line3497">3497. an object class, but this is for lump of royal jelly,</span>
  3502. <span id="line3498">3498. clove of garlic, bag of tricks, &c) with a few exceptions:</span>
  3503. <span id="line3499">3499. for "opening", don't match "bell of opening"; for monster</span>
  3504. <span id="line3500">3500. type ooze/pudding/slime don't match glob of same since that</span>
  3505. <span id="line3501">3501. ought to match "corpse/egg/figurine of type" too but won't */</span>
  3506. <span id="line3502">3502. || (check_of</span>
  3507. <span id="line3503">3503. && i != BELL_OF_OPENING</span>
  3508. <span id="line3504">3504. && (i < minglob || i > maxglob)</span>
  3509. <span id="line3505">3505. && (of = strstri(zn, " of ")) != 0</span>
  3510. <span id="line3506">3506. && wishymatch(name, of + 4, FALSE)) /* partial name */</span>
  3511. <span id="line3507">3507. || ((zn = OBJ_DESCR(objects[i])) != 0</span>
  3512. <span id="line3508">3508. && wishymatch(name, zn, FALSE)) /* objects[] description */</span>
  3513. <span id="line3509">3509. /* "cloth" should match "piece of cloth"; there's only one</span>
  3514. <span id="line3510">3510. description containing " of " so no special case handling */</span>
  3515. <span id="line3511">3511. || (zn && check_of && (of = strstri(zn, " of ")) != 0</span>
  3516. <span id="line3512">3512. && wishymatch(name, of + 4, FALSE)) /* partial description */</span>
  3517. <span id="line3513">3513. || ((zn = objects[i].oc_uname) != 0</span>
  3518. <span id="line3514">3514. && wishymatch(name, zn, FALSE)) /* user-called name */</span>
  3519. <span id="line3515">3515. ) {</span>
  3520. <span id="line3516">3516. validobjs[n++] = (short) i;</span>
  3521. <span id="line3517">3517. maxprob += (objects[i].oc_prob + xtra_prob);</span>
  3522. <span id="line3518">3518. }</span>
  3523. <span id="line3519">3519. }</span>
  3524. <span id="line3520">3520. </span>
  3525. <span id="line3521">3521. if (n > 0 && maxprob) {</span>
  3526. <span id="line3522">3522. prob = rn2(maxprob);</span>
  3527. <span id="line3523">3523. for (i = 0; i < n - 1; i++)</span>
  3528. <span id="line3524">3524. if ((prob -= (objects[validobjs[i]].oc_prob + xtra_prob)) < 0)</span>
  3529. <span id="line3525">3525. break;</span>
  3530. <span id="line3526">3526. return validobjs[i];</span>
  3531. <span id="line3527">3527. }</span>
  3532. <span id="line3528">3528. return STRANGE_OBJECT;</span>
  3533. <span id="line3529">3529. }</span>
  3534. <span id="line3530">3530. </span>
  3535. <span id="line3531">3531. int</span>
  3536. <span id="line3532">3532. shiny_obj(char oclass)</span>
  3537. <span id="line3533">3533. {</span>
  3538. <span id="line3534">3534. return (int) rnd_otyp_by_namedesc("shiny", oclass, 0);</span>
  3539. <span id="line3535">3535. }</span>
  3540. <span id="line3536">3536. </span>
  3541. <span id="line3537">3537. /* set wall under hero undiggable/unphaseable from string */</span>
  3542. <span id="line3538">3538. staticfn void</span>
  3543. <span id="line3539">3539. set_wallprop_from_str(char *bp)</span>
  3544. <span id="line3540">3540. {</span>
  3545. <span id="line3541">3541. int wall_prop = 0;</span>
  3546. <span id="line3542">3542. </span>
  3547. <span id="line3543">3543. if (strstr(bp, "undiggable ") || strstr(bp, "nondiggable "))</span>
  3548. <span id="line3544">3544. wall_prop |= W_NONDIGGABLE;</span>
  3549. <span id="line3545">3545. if (strstr(bp, "unphaseable ") || strstr(bp, "nonpasswall "))</span>
  3550. <span id="line3546">3546. wall_prop |= W_NONPASSWALL;</span>
  3551. <span id="line3547">3547. /* |= because wall_info (aka flags) is overloaded with other stuff */</span>
  3552. <span id="line3548">3548. if (wall_prop)</span>
  3553. <span id="line3549">3549. levl[u.ux][u.uy].wall_info |= wall_prop;</span>
  3554. <span id="line3550">3550. }</span>
  3555. <span id="line3551">3551. </span>
  3556. <span id="line3552">3552. /* in wizard mode, readobjnam() can accept wishes for traps and terrain */</span>
  3557. <span id="line3553">3553. staticfn struct obj *</span>
  3558. <span id="line3554">3554. wizterrainwish(struct _readobjnam_data *d)</span>
  3559. <span id="line3555">3555. {</span>
  3560. <span id="line3556">3556. struct rm *lev;</span>
  3561. <span id="line3557">3557. boolean madeterrain = FALSE, badterrain = FALSE, is_dbridge;</span>
  3562. <span id="line3558">3558. int trap;</span>
  3563. <span id="line3559">3559. unsigned oldtyp, ltyp;</span>
  3564. <span id="line3560">3560. coordxy x = u.ux, y = u.uy;</span>
  3565. <span id="line3561">3561. char *bp = d->bp, *p;</span>
  3566. <span id="line3562">3562. </span>
  3567. <span id="line3563">3563. for (trap = NO_TRAP + 1; trap < TRAPNUM; trap++) {</span>
  3568. <span id="line3564">3564. struct trap *t;</span>
  3569. <span id="line3565">3565. const char *tname;</span>
  3570. <span id="line3566">3566. </span>
  3571. <span id="line3567">3567. tname = trapname(trap, TRUE);</span>
  3572. <span id="line3568">3568. if (!str_start_is(bp, tname, TRUE))</span>
  3573. <span id="line3569">3569. continue;</span>
  3574. <span id="line3570">3570. /* found it; avoid stupid mistakes */</span>
  3575. <span id="line3571">3571. if (is_hole(trap) && !Can_fall_thru(&u.uz))</span>
  3576. <span id="line3572">3572. trap = ROCKTRAP;</span>
  3577. <span id="line3573">3573. if ((t = maketrap(x, y, trap)) != 0) {</span>
  3578. <span id="line3574">3574. trap = t->ttyp;</span>
  3579. <span id="line3575">3575. tname = trapname(trap, TRUE);</span>
  3580. <span id="line3576">3576. pline("%s%s.", An(tname),</span>
  3581. <span id="line3577">3577. (trap != MAGIC_PORTAL) ? "" : " to nowhere");</span>
  3582. <span id="line3578">3578. } else {</span>
  3583. <span id="line3579">3579. pline("Creation of %s failed.", an(tname));</span>
  3584. <span id="line3580">3580. }</span>
  3585. <span id="line3581">3581. return &hands_obj;</span>
  3586. <span id="line3582">3582. }</span>
  3587. <span id="line3583">3583. </span>
  3588. <span id="line3584">3584. /* furniture and terrain (use at your own risk; can clobber stairs</span>
  3589. <span id="line3585">3585. or place furniture on existing traps which shouldn't be allowed) */</span>
  3590. <span id="line3586">3586. lev = &levl[x][y];</span>
  3591. <span id="line3587">3587. oldtyp = lev->typ;</span>
  3592. <span id="line3588">3588. is_dbridge = (oldtyp == DRAWBRIDGE_DOWN || oldtyp == DRAWBRIDGE_UP);</span>
  3593. <span id="line3589">3589. p = eos(bp);</span>
  3594. <span id="line3590">3590. if (!BSTRCMPI(bp, p - 8, "fountain")) {</span>
  3595. <span id="line3591">3591. lev->typ = FOUNTAIN;</span>
  3596. <span id="line3592">3592. if (oldtyp != FOUNTAIN)</span>
  3597. <span id="line3593">3593. svl.level.flags.nfountains++;</span>
  3598. <span id="line3594">3594. lev->looted = d->looted ? F_LOOTED : 0; /* overlays 'flags' */</span>
  3599. <span id="line3595">3595. lev->blessedftn = d->blessed || !strncmpi(bp, "magic ", 6);</span>
  3600. <span id="line3596">3596. pline("A %sfountain.", lev->blessedftn ? "magic " : "");</span>
  3601. <span id="line3597">3597. madeterrain = TRUE;</span>
  3602. <span id="line3598">3598. } else if (!BSTRCMPI(bp, p - 6, "throne")) {</span>
  3603. <span id="line3599">3599. lev->typ = THRONE;</span>
  3604. <span id="line3600">3600. lev->looted = d->looted ? T_LOOTED : 0; /* overlays 'flags' */</span>
  3605. <span id="line3601">3601. pline("A throne.");</span>
  3606. <span id="line3602">3602. madeterrain = TRUE;</span>
  3607. <span id="line3603">3603. } else if (!BSTRCMPI(bp, p - 4, "sink")) {</span>
  3608. <span id="line3604">3604. lev->typ = SINK;</span>
  3609. <span id="line3605">3605. if (oldtyp != SINK)</span>
  3610. <span id="line3606">3606. svl.level.flags.nsinks++;</span>
  3611. <span id="line3607">3607. lev->looted = d->looted ? (S_LPUDDING | S_LDWASHER | S_LRING) : 0;</span>
  3612. <span id="line3608">3608. pline("A sink.");</span>
  3613. <span id="line3609">3609. madeterrain = TRUE;</span>
  3614. <span id="line3610">3610. </span>
  3615. <span id="line3611">3611. /* ("water" matches "potion of water" rather than terrain) */</span>
  3616. <span id="line3612">3612. } else if (!BSTRCMPI(bp, p - 4, "pool")</span>
  3617. <span id="line3613">3613. || !BSTRCMPI(bp, p - 4, "moat")</span>
  3618. <span id="line3614">3614. || !BSTRCMPI(bp, p - 13, "wall of water")) {</span>
  3619. <span id="line3615">3615. long save_prop;</span>
  3620. <span id="line3616">3616. const char *new_water;</span>
  3621. <span id="line3617">3617. </span>
  3622. <span id="line3618">3618. ltyp = !BSTRCMPI(bp, p - 4, "pool") ? POOL</span>
  3623. <span id="line3619">3619. : !BSTRCMPI(bp, p - 4, "moat") ? MOAT</span>
  3624. <span id="line3620">3620. : WATER;</span>
  3625. <span id="line3621">3621. if (!is_dbridge) {</span>
  3626. <span id="line3622">3622. lev->typ = ltyp;</span>
  3627. <span id="line3623">3623. lev->flags = 0;</span>
  3628. <span id="line3624">3624. } else {</span>
  3629. <span id="line3625">3625. /* drawbridgemask overloads flags */</span>
  3630. <span id="line3626">3626. lev->drawbridgemask &= ~DB_UNDER;</span>
  3631. <span id="line3627">3627. lev->drawbridgemask |= DB_MOAT;</span>
  3632. <span id="line3628">3628. }</span>
  3633. <span id="line3629">3629. del_engr_at(x, y);</span>
  3634. <span id="line3630">3630. if (!is_dbridge) {</span>
  3635. <span id="line3631">3631. save_prop = EHalluc_resistance;</span>
  3636. <span id="line3632">3632. EHalluc_resistance = 1;</span>
  3637. <span id="line3633">3633. new_water = waterbody_name(x, y);</span>
  3638. <span id="line3634">3634. EHalluc_resistance = save_prop;</span>
  3639. <span id="line3635">3635. pline("%s.", An(new_water));</span>
  3640. <span id="line3636">3636. /* Must manually make kelp! */</span>
  3641. <span id="line3637">3637. } else {</span>
  3642. <span id="line3638">3638. dbterrainmesg("Moat", x, y);</span>
  3643. <span id="line3639">3639. }</span>
  3644. <span id="line3640">3640. water_damage_chain(svl.level.objects[x][y], TRUE);</span>
  3645. <span id="line3641">3641. madeterrain = TRUE;</span>
  3646. <span id="line3642">3642. </span>
  3647. <span id="line3643">3643. /* also matches "molten lava" */</span>
  3648. <span id="line3644">3644. } else if (!BSTRCMPI(bp, p - 4, "lava")</span>
  3649. <span id="line3645">3645. || !BSTRCMPI(bp, p - 12, "wall of lava")) {</span>
  3650. <span id="line3646">3646. ltyp = !BSTRCMPI(bp, p - 12, "wall of lava") ? LAVAWALL : LAVAPOOL;</span>
  3651. <span id="line3647">3647. if (!is_dbridge) {</span>
  3652. <span id="line3648">3648. lev->typ = ltyp;</span>
  3653. <span id="line3649">3649. lev->flags = 0;</span>
  3654. <span id="line3650">3650. } else {</span>
  3655. <span id="line3651">3651. /* drawbridgemask overloads flags */</span>
  3656. <span id="line3652">3652. lev->drawbridgemask &= ~DB_UNDER;</span>
  3657. <span id="line3653">3653. lev->drawbridgemask |= DB_LAVA;</span>
  3658. <span id="line3654">3654. }</span>
  3659. <span id="line3655">3655. del_engr_at(x, y);</span>
  3660. <span id="line3656">3656. if (!is_dbridge) {</span>
  3661. <span id="line3657">3657. pline("A %s of molten lava.",</span>
  3662. <span id="line3658">3658. (lev->typ == LAVAPOOL) ? "pool" : "wall");</span>
  3663. <span id="line3659">3659. if (!(Levitation || Flying) || lev->typ == LAVAWALL)</span>
  3664. <span id="line3660">3660. pooleffects(FALSE);</span>
  3665. <span id="line3661">3661. } else {</span>
  3666. <span id="line3662">3662. dbterrainmesg("Lava", x, y);</span>
  3667. <span id="line3663">3663. }</span>
  3668. <span id="line3664">3664. fire_damage_chain(svl.level.objects[x][y], TRUE, TRUE, x, y);</span>
  3669. <span id="line3665">3665. madeterrain = TRUE;</span>
  3670. <span id="line3666">3666. } else if (!BSTRCMPI(bp, p - 3, "ice")) {</span>
  3671. <span id="line3667">3667. if (!is_dbridge) {</span>
  3672. <span id="line3668">3668. lev->typ = ICE;</span>
  3673. <span id="line3669">3669. /* icedpool overloads flags; specifies what ice will melt into */</span>
  3674. <span id="line3670">3670. lev->icedpool = (oldtyp == ROOM) ? ICED_POOL : ICED_MOAT;</span>
  3675. <span id="line3671">3671. } else {</span>
  3676. <span id="line3672">3672. /* drawbridgemask overloads flags */</span>
  3677. <span id="line3673">3673. lev->drawbridgemask &= ~DB_UNDER;</span>
  3678. <span id="line3674">3674. lev->drawbridgemask |= DB_ICE;</span>
  3679. <span id="line3675">3675. }</span>
  3680. <span id="line3676">3676. del_engr_at(x, y);</span>
  3681. <span id="line3677">3677. </span>
  3682. <span id="line3678">3678. if (!strncmpi(bp, "melting ", 8))</span>
  3683. <span id="line3679">3679. start_melt_ice_timeout(x, y, 0L);</span>
  3684. <span id="line3680">3680. </span>
  3685. <span id="line3681">3681. if (!is_dbridge) {</span>
  3686. <span id="line3682">3682. char icebuf[40];</span>
  3687. <span id="line3683">3683. </span>
  3688. <span id="line3684">3684. pline("%s.", upstart(ice_descr(x, y, icebuf)));</span>
  3689. <span id="line3685">3685. } else {</span>
  3690. <span id="line3686">3686. dbterrainmesg("Ice", x, y);</span>
  3691. <span id="line3687">3687. }</span>
  3692. <span id="line3688">3688. madeterrain = TRUE;</span>
  3693. <span id="line3689">3689. } else if (!BSTRCMPI(bp, p - 5, "altar")) {</span>
  3694. <span id="line3690">3690. aligntyp al;</span>
  3695. <span id="line3691">3691. </span>
  3696. <span id="line3692">3692. lev->typ = ALTAR;</span>
  3697. <span id="line3693">3693. if (!strncmpi(bp, "chaotic ", 8))</span>
  3698. <span id="line3694">3694. al = A_CHAOTIC;</span>
  3699. <span id="line3695">3695. else if (!strncmpi(bp, "neutral ", 8))</span>
  3700. <span id="line3696">3696. al = A_NEUTRAL;</span>
  3701. <span id="line3697">3697. else if (!strncmpi(bp, "lawful ", 7))</span>
  3702. <span id="line3698">3698. al = A_LAWFUL;</span>
  3703. <span id="line3699">3699. else if (!strncmpi(bp, "unaligned ", 10))</span>
  3704. <span id="line3700">3700. al = A_NONE;</span>
  3705. <span id="line3701">3701. else /* -1 - A_CHAOTIC, 0 - A_NEUTRAL, 1 - A_LAWFUL */</span>
  3706. <span id="line3702">3702. al = !rn2(6) ? A_NONE : (rn2((int) A_LAWFUL + 2) - 1);</span>
  3707. <span id="line3703">3703. lev->altarmask = Align2amask(al); /* overlays 'flags' */</span>
  3708. <span id="line3704">3704. pline("%s altar.", An(align_str(al)));</span>
  3709. <span id="line3705">3705. madeterrain = TRUE;</span>
  3710. <span id="line3706">3706. } else if (!BSTRCMPI(bp, p - 5, "grave")</span>
  3711. <span id="line3707">3707. || !BSTRCMPI(bp, p - 9, "headstone")) {</span>
  3712. <span id="line3708">3708. make_grave(x, y, (char *) 0);</span>
  3713. <span id="line3709">3709. if (IS_GRAVE(lev->typ)) {</span>
  3714. <span id="line3710">3710. lev->looted = 0; /* overlays 'flags' */</span>
  3715. <span id="line3711">3711. lev->disturbed = d->looted ? 1 : 0;</span>
  3716. <span id="line3712">3712. pline("A %sgrave.", lev->disturbed ? "disturbed " : "");</span>
  3717. <span id="line3713">3713. madeterrain = TRUE;</span>
  3718. <span id="line3714">3714. } else {</span>
  3719. <span id="line3715">3715. pline("Can't place a grave here.");</span>
  3720. <span id="line3716">3716. badterrain = TRUE;</span>
  3721. <span id="line3717">3717. }</span>
  3722. <span id="line3718">3718. } else if (!BSTRCMPI(bp, p - 4, "tree")) {</span>
  3723. <span id="line3719">3719. lev->typ = TREE;</span>
  3724. <span id="line3720">3720. lev->looted = d->looted ? (TREE_LOOTED | TREE_SWARM) : 0;</span>
  3725. <span id="line3721">3721. set_wallprop_from_str(bp);</span>
  3726. <span id="line3722">3722. pline("A tree.");</span>
  3727. <span id="line3723">3723. madeterrain = TRUE;</span>
  3728. <span id="line3724">3724. } else if (!BSTRCMPI(bp, p - 4, "bars")) {</span>
  3729. <span id="line3725">3725. lev->typ = IRONBARS;</span>
  3730. <span id="line3726">3726. lev->flags = 0;</span>
  3731. <span id="line3727">3727. set_wallprop_from_str(bp);</span>
  3732. <span id="line3728">3728. /* [FIXME: if this isn't a wall or door location where 'horizontal'</span>
  3733. <span id="line3729">3729. is already set up, that should be calculated for this spot.</span>
  3734. <span id="line3730">3730. Unfortunately, it can be tricky; placing one in open space</span>
  3735. <span id="line3731">3731. and then another adjacent might need to recalculate first one.] */</span>
  3736. <span id="line3732">3732. pline("Iron bars.");</span>
  3737. <span id="line3733">3733. madeterrain = TRUE;</span>
  3738. <span id="line3734">3734. } else if (!BSTRCMPI(bp, p - 5, "cloud")) {</span>
  3739. <span id="line3735">3735. lev->typ = CLOUD;</span>
  3740. <span id="line3736">3736. lev->flags = 0;</span>
  3741. <span id="line3737">3737. pline("A cloud.");</span>
  3742. <span id="line3738">3738. del_engr_at(x, y);</span>
  3743. <span id="line3739">3739. madeterrain = TRUE;</span>
  3744. <span id="line3740">3740. } else if (!BSTRCMPI(bp, p - 4, "door")</span>
  3745. <span id="line3741">3741. || (d->doorless && !BSTRCMPI(bp, p - 7, "doorway"))) {</span>
  3746. <span id="line3742">3742. char dbuf[40];</span>
  3747. <span id="line3743">3743. unsigned old_wall_info;</span>
  3748. <span id="line3744">3744. boolean secret = !BSTRCMPI(bp, p - 11, "secret door");</span>
  3749. <span id="line3745">3745. </span>
  3750. <span id="line3746">3746. /* require door or wall so that the 'horizontal' flag will</span>
  3751. <span id="line3747">3747. already have the correct value; player might choose to put</span>
  3752. <span id="line3748">3748. DOOR on top of existing DOOR or SDOOR on top of existing SDOOR</span>
  3753. <span id="line3749">3749. to control its trapped state; iron bars are surrogate walls;</span>
  3754. <span id="line3750">3750. a previously dug wall looks like corridor but is actually a</span>
  3755. <span id="line3751">3751. doorless doorway so will be acceptable here */</span>
  3756. <span id="line3752">3752. if (lev->typ == DOOR || lev->typ == SDOOR</span>
  3757. <span id="line3753">3753. || (IS_WALL(lev->typ) && lev->typ != DBWALL)</span>
  3758. <span id="line3754">3754. || lev->typ == IRONBARS) {</span>
  3759. <span id="line3755">3755. /* remember previous wall info [is this right for iron bars?] */</span>
  3760. <span id="line3756">3756. old_wall_info = (lev->typ != DOOR) ? lev->wall_info : 0;</span>
  3761. <span id="line3757">3757. /* set the new terrain type */</span>
  3762. <span id="line3758">3758. lev->typ = secret ? SDOOR : DOOR;</span>
  3763. <span id="line3759">3759. lev->wall_info = 0; /* overlays 'flags' */</span>
  3764. <span id="line3760">3760. /* lev->horizontal stays as-is */</span>
  3765. <span id="line3761">3761. if (Is_rogue_level(&u.uz)) {</span>
  3766. <span id="line3762">3762. /* all doors on the rogue level are doorless; locking magic</span>
  3767. <span id="line3763">3763. there converts them into walls rather than closed doors */</span>
  3768. <span id="line3764">3764. d->doorless = 1;</span>
  3769. <span id="line3765">3765. d->locked = d->closed = d->open = d->broken = 0;</span>
  3770. <span id="line3766">3766. }</span>
  3771. <span id="line3767">3767. /* if not locked, secret doors are implicitly closed but</span>
  3772. <span id="line3768">3768. mustn't be set that way explicitly because they use both</span>
  3773. <span id="line3769">3769. doormask and wall_info which both overload rm[x][y].flags</span>
  3774. <span id="line3770">3770. (CLOSED overlaps wall_info bits, LOCKED and TRAPPED don't);</span>
  3775. <span id="line3771">3771. conversion from SDOOR to DOOR changes NODOOR to CLOSED */</span>
  3776. <span id="line3772">3772. lev->doormask = d->locked ? D_LOCKED</span>
  3777. <span id="line3773">3773. : (d->doorless || secret) ? D_NODOOR</span>
  3778. <span id="line3774">3774. : d->open ? D_ISOPEN</span>
  3779. <span id="line3775">3775. : d->broken ? D_BROKEN</span>
  3780. <span id="line3776">3776. : D_CLOSED;</span>
  3781. <span id="line3777">3777. /* SDOOR uses wall_info, restore relevant bits.</span>
  3782. <span id="line3778">3778. * FIXME? if we're changing a regular door into a secret door,</span>
  3783. <span id="line3779">3779. * old_wall_info bits will be 0 instead of being set properly.</span>
  3784. <span id="line3780">3780. * Probably only matters if player uses Passes_walls and a wish</span>
  3785. <span id="line3781">3781. * to turn a T- or cross-wall into a door, losing wall info,</span>
  3786. <span id="line3782">3782. * and then another wish to turn that door into a secret door. */</span>
  3787. <span id="line3783">3783. if (secret)</span>
  3788. <span id="line3784">3784. lev->wall_info |= (old_wall_info & WM_MASK);</span>
  3789. <span id="line3785">3785. /* set up trapped flag; open door states aren't eligible */</span>
  3790. <span id="line3786">3786. if (d->trapped == 2 /* 2: wish includes explicit "untrapped" */</span>
  3791. <span id="line3787">3787. || ((lev->doormask & (D_LOCKED | D_CLOSED)) == 0</span>
  3792. <span id="line3788">3788. /* D_CLOSED is implicit for secret doors */</span>
  3793. <span id="line3789">3789. && !secret))</span>
  3794. <span id="line3790">3790. d->trapped = 0;</span>
  3795. <span id="line3791">3791. if (d->trapped)</span>
  3796. <span id="line3792">3792. lev->doormask |= D_TRAPPED;</span>
  3797. <span id="line3793">3793. /* feedback */</span>
  3798. <span id="line3794">3794. dbuf[0] = '\0';</span>
  3799. <span id="line3795">3795. if (lev->doormask & D_TRAPPED)</span>
  3800. <span id="line3796">3796. Strcat(dbuf, "trapped ");</span>
  3801. <span id="line3797">3797. if (lev->doormask & D_LOCKED)</span>
  3802. <span id="line3798">3798. Strcat(dbuf, "locked ");</span>
  3803. <span id="line3799">3799. if (lev->typ == SDOOR) {</span>
  3804. <span id="line3800">3800. Strcat(dbuf, "secret door");</span>
  3805. <span id="line3801">3801. } else {</span>
  3806. <span id="line3802">3802. /* these should be mutually exclusive but we describe them</span>
  3807. <span id="line3803">3803. as if they're independent to maybe catch future bugs... */</span>
  3808. <span id="line3804">3804. if (lev->doormask & D_CLOSED)</span>
  3809. <span id="line3805">3805. Strcat(dbuf, "closed ");</span>
  3810. <span id="line3806">3806. if (lev->doormask & D_ISOPEN)</span>
  3811. <span id="line3807">3807. Strcat(dbuf, "open ");</span>
  3812. <span id="line3808">3808. if (lev->doormask & D_BROKEN)</span>
  3813. <span id="line3809">3809. Strcat(dbuf, "broken ");</span>
  3814. <span id="line3810">3810. if ((lev->doormask & ~D_TRAPPED) == D_NODOOR)</span>
  3815. <span id="line3811">3811. Strcat(dbuf, "doorless doorway");</span>
  3816. <span id="line3812">3812. else</span>
  3817. <span id="line3813">3813. Strcat(dbuf, "door");</span>
  3818. <span id="line3814">3814. }</span>
  3819. <span id="line3815">3815. pline("%s.", upstart(an(dbuf)));</span>
  3820. <span id="line3816">3816. madeterrain = TRUE;</span>
  3821. <span id="line3817">3817. } else {</span>
  3822. <span id="line3818">3818. Strcpy(dbuf, secret ? "secret door" : "door");</span>
  3823. <span id="line3819">3819. pline("%s requires door or wall location.", upstart(dbuf));</span>
  3824. <span id="line3820">3820. badterrain = TRUE;</span>
  3825. <span id="line3821">3821. }</span>
  3826. <span id="line3822">3822. } else if (!BSTRCMPI(bp, p - 4, "wall")</span>
  3827. <span id="line3823">3823. && (bp == p - 4 || p[-5] == ' ')) {</span>
  3828. <span id="line3824">3824. schar wall = HWALL;</span>
  3829. <span id="line3825">3825. </span>
  3830. <span id="line3826">3826. if ((isok(u.ux, u.uy-1) && IS_WALL(levl[u.ux][u.uy-1].typ))</span>
  3831. <span id="line3827">3827. || (isok(u.ux, u.uy+1) && IS_WALL(levl[u.ux][u.uy+1].typ)))</span>
  3832. <span id="line3828">3828. wall = VWALL;</span>
  3833. <span id="line3829">3829. madeterrain = TRUE;</span>
  3834. <span id="line3830">3830. lev->typ = wall;</span>
  3835. <span id="line3831">3831. lev->flags = 0;</span>
  3836. <span id="line3832">3832. set_wallprop_from_str(bp);</span>
  3837. <span id="line3833">3833. fix_wall_spines(max(0,u.ux-1), max(0,u.uy-1),</span>
  3838. <span id="line3834">3834. min(COLNO,u.ux+1), min(ROWNO,u.uy+1));</span>
  3839. <span id="line3835">3835. pline("A wall.");</span>
  3840. <span id="line3836">3836. } else if (!BSTRCMPI(bp, p - 15, "secret corridor")) {</span>
  3841. <span id="line3837">3837. if (lev->typ == CORR) {</span>
  3842. <span id="line3838">3838. lev->typ = SCORR;</span>
  3843. <span id="line3839">3839. /* neither CORR nor SCORR uses 'flags' or 'horizontal' */</span>
  3844. <span id="line3840">3840. pline("Secret corridor.");</span>
  3845. <span id="line3841">3841. madeterrain = TRUE;</span>
  3846. <span id="line3842">3842. } else {</span>
  3847. <span id="line3843">3843. pline("Secret corridor requires corridor location.");</span>
  3848. <span id="line3844">3844. badterrain = TRUE;</span>
  3849. <span id="line3845">3845. }</span>
  3850. <span id="line3846">3846. } else if (!BSTRCMPI(bp, p - 4, "room")</span>
  3851. <span id="line3847">3847. || !BSTRCMPI(bp, p - 5, "floor")</span>
  3852. <span id="line3848">3848. || !BSTRCMPI(bp, p - 6, "ground")) {</span>
  3853. <span id="line3849">3849. if (oldtyp == ROOM</span>
  3854. <span id="line3850">3850. || (IS_FURNITURE(oldtyp) && CAN_OVERWRITE_TERRAIN(oldtyp))</span>
  3855. <span id="line3851">3851. || oldtyp == ICE || is_pool_or_lava(x, y)) {</span>
  3856. <span id="line3852">3852. struct trap *t;</span>
  3857. <span id="line3853">3853. </span>
  3858. <span id="line3854">3854. lev->typ = ROOM;</span>
  3859. <span id="line3855">3855. pline("Room floor.");</span>
  3860. <span id="line3856">3856. if (IS_FURNITURE(oldtyp))</span>
  3861. <span id="line3857">3857. count_level_features();</span>
  3862. <span id="line3858">3858. if ((t = t_at(x, y)) != 0 && t->ttyp != MAGIC_PORTAL)</span>
  3863. <span id="line3859">3859. deltrap(t);</span>
  3864. <span id="line3860">3860. madeterrain = TRUE;</span>
  3865. <span id="line3861">3861. } else if (is_dbridge) {</span>
  3866. <span id="line3862">3862. lev->drawbridgemask &= ~DB_UNDER;</span>
  3867. <span id="line3863">3863. lev->drawbridgemask |= DB_FLOOR;</span>
  3868. <span id="line3864">3864. dbterrainmesg("Floor", x, y);</span>
  3869. <span id="line3865">3865. madeterrain = TRUE;</span>
  3870. <span id="line3866">3866. } else {</span>
  3871. <span id="line3867">3867. pline("Room|floor|ground not allowed here.");</span>
  3872. <span id="line3868">3868. badterrain = TRUE;</span>
  3873. <span id="line3869">3869. }</span>
  3874. <span id="line3870">3870. }</span>
  3875. <span id="line3871">3871. </span>
  3876. <span id="line3872">3872. if (madeterrain) {</span>
  3877. <span id="line3873">3873. feel_newsym(x, y); /* map the spot where the wish occurred */</span>
  3878. <span id="line3874">3874. </span>
  3879. <span id="line3875">3875. /* hero started at <x,y> but might not be there anymore (create</span>
  3880. <span id="line3876">3876. lava, decline to die, and get teleported away to safety) */</span>
  3881. <span id="line3877">3877. if (u.uinwater && !is_pool(u.ux, u.uy)) {</span>
  3882. <span id="line3878">3878. set_uinwater(0); /* u.uinwater = 0; leave the water */</span>
  3883. <span id="line3879">3879. docrt();</span>
  3884. <span id="line3880">3880. /* [block/unblock_point handled by docrt -> vision_recalc] */</span>
  3885. <span id="line3881">3881. } else {</span>
  3886. <span id="line3882">3882. if (u.utrap && u.utraptype == TT_LAVA && !is_lava(u.ux, u.uy))</span>
  3887. <span id="line3883">3883. reset_utrap(FALSE);</span>
  3888. <span id="line3884">3884. recalc_block_point(x, y);</span>
  3889. <span id="line3885">3885. }</span>
  3890. <span id="line3886">3886. </span>
  3891. <span id="line3887">3887. /* fixups for replaced terrain that aren't handled above */</span>
  3892. <span id="line3888">3888. if (IS_FOUNTAIN(oldtyp) || IS_SINK(oldtyp))</span>
  3893. <span id="line3889">3889. count_level_features(); /* update level.flags.nfountains,nsinks */</span>
  3894. <span id="line3890">3890. if (!is_ice(x, y))</span>
  3895. <span id="line3891">3891. spot_stop_timers(x, y, MELT_ICE_AWAY);</span>
  3896. <span id="line3892">3892. /* horizontal is overlaid by fountain->blessedftn, grave->disturbed */</span>
  3897. <span id="line3893">3893. if (IS_FOUNTAIN(oldtyp) || IS_GRAVE(oldtyp)</span>
  3898. <span id="line3894">3894. || IS_WALL(oldtyp) || oldtyp == IRONBARS</span>
  3899. <span id="line3895">3895. || IS_DOOR(oldtyp) || oldtyp == SDOOR) {</span>
  3900. <span id="line3896">3896. /* when new terrain is a fountain, 'blessedftn' was explicitly</span>
  3901. <span id="line3897">3897. set above; likewise for grave and 'disturbed'; when it's a</span>
  3902. <span id="line3898">3898. door, the old type was a wall or a door and we retain the</span>
  3903. <span id="line3899">3899. 'horizontal' value from those */</span>
  3904. <span id="line3900">3900. if (!IS_FOUNTAIN(lev->typ) && !IS_GRAVE(lev->typ)</span>
  3905. <span id="line3901">3901. && !IS_DOOR(lev->typ) && lev->typ != SDOOR)</span>
  3906. <span id="line3902">3902. lev->horizontal = 0; /* also clears blessedftn, disturbed */</span>
  3907. <span id="line3903">3903. }</span>
  3908. <span id="line3904">3904. /* note: lev->lit and lev->nondiggable retain their values even</span>
  3909. <span id="line3905">3905. though those might not make sense with the new terrain */</span>
  3910. <span id="line3906">3906. </span>
  3911. <span id="line3907">3907. /* might have changed terrain from something that blocked</span>
  3912. <span id="line3908">3908. levitation and flying to something that doesn't (levitating</span>
  3913. <span id="line3909">3909. while in xorn form and replacing solid stone with furniture) */</span>
  3914. <span id="line3910">3910. switch_terrain();</span>
  3915. <span id="line3911">3911. }</span>
  3916. <span id="line3912">3912. if (madeterrain || badterrain)</span>
  3917. <span id="line3913">3913. return &hands_obj;</span>
  3918. <span id="line3914">3914. </span>
  3919. <span id="line3915">3915. return (struct obj *) 0;</span>
  3920. <span id="line3916">3916. }</span>
  3921. <span id="line3917">3917. </span>
  3922. <span id="line3918">3918. /* message common to several wizterrainwish() results */</span>
  3923. <span id="line3919">3919. staticfn void</span>
  3924. <span id="line3920">3920. dbterrainmesg(</span>
  3925. <span id="line3921">3921. const char *newtype,</span>
  3926. <span id="line3922">3922. coordxy x, coordxy y)</span>
  3927. <span id="line3923">3923. {</span>
  3928. <span id="line3924">3924. pline("%s %s the drawbridge.", newtype,</span>
  3929. <span id="line3925">3925. (levl[x][y].typ == DRAWBRIDGE_UP) ? "in front of" : "under");</span>
  3930. <span id="line3926">3926. }</span>
  3931. <span id="line3927">3927. </span>
  3932. <span id="line3928">3928. #define TIN_UNDEFINED 0</span>
  3933. <span id="line3929">3929. #define TIN_EMPTY 1</span>
  3934. <span id="line3930">3930. #define TIN_SPINACH 2</span>
  3935. <span id="line3931">3931. </span>
  3936. <span id="line3932">3932. staticfn void</span>
  3937. <span id="line3933">3933. readobjnam_init(char *bp, struct _readobjnam_data *d)</span>
  3938. <span id="line3934">3934. {</span>
  3939. <span id="line3935">3935. d->otmp = (struct obj *) 0;</span>
  3940. <span id="line3936">3936. d->cnt = d->spe = d->spesgn = d->typ = 0;</span>
  3941. <span id="line3937">3937. d->very = d->rechrg = d->blessed = d->uncursed = d->iscursed</span>
  3942. <span id="line3938">3938. = d->ispoisoned = d->isgreased = d->eroded = d->eroded2</span>
  3943. <span id="line3939">3939. = d->erodeproof = d->halfeaten = d->islit = d->unlabeled</span>
  3944. <span id="line3940">3940. = d->ishistoric = d->isdiluted /* statues, potions */</span>
  3945. <span id="line3941">3941. /* box/chest and wizard mode door */</span>
  3946. <span id="line3942">3942. = d->trapped = d->locked = d->unlocked = d->broken</span>
  3947. <span id="line3943">3943. = d->open = d->closed = d->doorless /* wizard mode door */</span>
  3948. <span id="line3944">3944. = d->looted /* wizard mode fountain/sink/throne/tree and grave */</span>
  3949. <span id="line3945">3945. = d->real = d->fake = 0; /* Amulet */</span>
  3950. <span id="line3946">3946. d->tvariety = RANDOM_TIN;</span>
  3951. <span id="line3947">3947. d->mgend = -1; /* not specified, aka random */</span>
  3952. <span id="line3948">3948. d->mntmp = NON_PM;</span>
  3953. <span id="line3949">3949. d->contents = TIN_UNDEFINED;</span>
  3954. <span id="line3950">3950. d->oclass = 0;</span>
  3955. <span id="line3951">3951. d->actualn = d->dn = d->un = 0;</span>
  3956. <span id="line3952">3952. d->wetness = 0;</span>
  3957. <span id="line3953">3953. d->gsize = 0;</span>
  3958. <span id="line3954">3954. d->zombify = FALSE;</span>
  3959. <span id="line3955">3955. d->bp = d->origbp = bp;</span>
  3960. <span id="line3956">3956. d->p = (char *) 0;</span>
  3961. <span id="line3957">3957. d->name = (const char *) 0;</span>
  3962. <span id="line3958">3958. d->ftype = svc.context.current_fruit;</span>
  3963. <span id="line3959">3959. (void) memset(d->globbuf, '\0', sizeof d->globbuf);</span>
  3964. <span id="line3960">3960. (void) memset(d->fruitbuf, '\0', sizeof d->fruitbuf);</span>
  3965. <span id="line3961">3961. }</span>
  3966. <span id="line3962">3962. </span>
  3967. <span id="line3963">3963. /* return 1 if d->bp is empty or contains only various qualifiers like</span>
  3968. <span id="line3964">3964. "blessed", "rustproof", and so on, or 0 if anything else is present */</span>
  3969. <span id="line3965">3965. staticfn int</span>
  3970. <span id="line3966">3966. readobjnam_preparse(struct _readobjnam_data *d)</span>
  3971. <span id="line3967">3967. {</span>
  3972. <span id="line3968">3968. char *save_bp = 0;</span>
  3973. <span id="line3969">3969. int more_l = 0, res = 1;</span>
  3974. <span id="line3970">3970. </span>
  3975. <span id="line3971">3971. for (;;) {</span>
  3976. <span id="line3972">3972. int l;</span>
  3977. <span id="line3973">3973. </span>
  3978. <span id="line3974">3974. if (!d->bp || !*d->bp)</span>
  3979. <span id="line3975">3975. break;</span>
  3980. <span id="line3976">3976. res = 0;</span>
  3981. <span id="line3977">3977. </span>
  3982. <span id="line3978">3978. if (!strncmpi(d->bp, "an ", l = 3) || !strncmpi(d->bp, "a ", l = 2)) {</span>
  3983. <span id="line3979">3979. d->cnt = 1;</span>
  3984. <span id="line3980">3980. } else if (!strncmpi(d->bp, "the ", l = 4)) {</span>
  3985. <span id="line3981">3981. ; /* just increment `bp' by `l' below */</span>
  3986. <span id="line3982">3982. } else if (!d->cnt && digit(*d->bp) && strcmp(d->bp, "0")) {</span>
  3987. <span id="line3983">3983. d->cnt = atoi(d->bp);</span>
  3988. <span id="line3984">3984. while (digit(*d->bp))</span>
  3989. <span id="line3985">3985. d->bp++;</span>
  3990. <span id="line3986">3986. while (*d->bp == ' ')</span>
  3991. <span id="line3987">3987. d->bp++;</span>
  3992. <span id="line3988">3988. l = 0;</span>
  3993. <span id="line3989">3989. } else if (*d->bp == '+' || *d->bp == '-') {</span>
  3994. <span id="line3990">3990. d->spesgn = (*d->bp++ == '+') ? 1 : -1;</span>
  3995. <span id="line3991">3991. d->spe = atoi(d->bp);</span>
  3996. <span id="line3992">3992. while (digit(*d->bp))</span>
  3997. <span id="line3993">3993. d->bp++;</span>
  3998. <span id="line3994">3994. while (*d->bp == ' ')</span>
  3999. <span id="line3995">3995. d->bp++;</span>
  4000. <span id="line3996">3996. l = 0;</span>
  4001. <span id="line3997">3997. } else if (!strncmpi(d->bp, "blessed ", l = 8)</span>
  4002. <span id="line3998">3998. || !strncmpi(d->bp, "holy ", l = 5)) {</span>
  4003. <span id="line3999">3999. d->blessed = 1, d->uncursed = d->iscursed = 0;</span>
  4004. <span id="line4000">4000. } else if (!strncmpi(d->bp, "cursed ", l = 7)</span>
  4005. <span id="line4001">4001. || !strncmpi(d->bp, "unholy ", l = 7)) {</span>
  4006. <span id="line4002">4002. d->iscursed = 1, d->blessed = d->uncursed = 0;</span>
  4007. <span id="line4003">4003. } else if (!strncmpi(d->bp, "uncursed ", l = 9)) {</span>
  4008. <span id="line4004">4004. d->uncursed = 1, d->blessed = d->iscursed = 0;</span>
  4009. <span id="line4005">4005. } else if (!strncmpi(d->bp, "rustproof ", l = 10)</span>
  4010. <span id="line4006">4006. || !strncmpi(d->bp, "erodeproof ", l = 11)</span>
  4011. <span id="line4007">4007. || !strncmpi(d->bp, "corrodeproof ", l = 13)</span>
  4012. <span id="line4008">4008. || !strncmpi(d->bp, "fixed ", l = 6)</span>
  4013. <span id="line4009">4009. || !strncmpi(d->bp, "fireproof ", l = 10)</span>
  4014. <span id="line4010">4010. || !strncmpi(d->bp, "rotproof ", l = 9)</span>
  4015. <span id="line4011">4011. || !strncmpi(d->bp, "tempered ", l = 9)</span>
  4016. <span id="line4012">4012. || !strncmpi(d->bp, "crackproof ", l = 11)) {</span>
  4017. <span id="line4013">4013. d->erodeproof = 1;</span>
  4018. <span id="line4014">4014. } else if (!strncmpi(d->bp, "lit ", l = 4)</span>
  4019. <span id="line4015">4015. || !strncmpi(d->bp, "burning ", l = 8)) {</span>
  4020. <span id="line4016">4016. d->islit = 1;</span>
  4021. <span id="line4017">4017. } else if (!strncmpi(d->bp, "unlit ", l = 6)</span>
  4022. <span id="line4018">4018. || !strncmpi(d->bp, "extinguished ", l = 13)) {</span>
  4023. <span id="line4019">4019. d->islit = 0;</span>
  4024. <span id="line4020">4020. </span>
  4025. <span id="line4021">4021. /* "wet" and "moist" are only applicable for towels */</span>
  4026. <span id="line4022">4022. } else if (!strncmpi(d->bp, "moist ", l = 6)</span>
  4027. <span id="line4023">4023. || !strncmpi(d->bp, "wet ", l = 4)) {</span>
  4028. <span id="line4024">4024. if (!strncmpi(d->bp, "wet ", 4))</span>
  4029. <span id="line4025">4025. d->wetness = 3 + rn2(3); /* 3..5 */</span>
  4030. <span id="line4026">4026. else</span>
  4031. <span id="line4027">4027. d->wetness = rnd(2); /* 1..2 */</span>
  4032. <span id="line4028">4028. </span>
  4033. <span id="line4029">4029. /* "unlabeled" and "blank" are synonymous */</span>
  4034. <span id="line4030">4030. } else if (!strncmpi(d->bp, "unlabeled ", l = 10)</span>
  4035. <span id="line4031">4031. || !strncmpi(d->bp, "unlabelled ", l = 11)</span>
  4036. <span id="line4032">4032. || !strncmpi(d->bp, "blank ", l = 6)) {</span>
  4037. <span id="line4033">4033. d->unlabeled = 1;</span>
  4038. <span id="line4034">4034. } else if (!strncmpi(d->bp, "poisoned ", l = 9)) {</span>
  4039. <span id="line4035">4035. d->ispoisoned = 1;</span>
  4040. <span id="line4036">4036. </span>
  4041. <span id="line4037">4037. /* "trapped" recognized but not honored outside wizard mode */</span>
  4042. <span id="line4038">4038. } else if (!strncmpi(d->bp, "trapped ", l = 8)) {</span>
  4043. <span id="line4039">4039. d->trapped = 0; /* undo any previous "untrapped" */</span>
  4044. <span id="line4040">4040. if (wizard)</span>
  4045. <span id="line4041">4041. d->trapped = 1;</span>
  4046. <span id="line4042">4042. } else if (!strncmpi(d->bp, "untrapped ", l = 10)) {</span>
  4047. <span id="line4043">4043. d->trapped = 2; /* not trapped */</span>
  4048. <span id="line4044">4044. </span>
  4049. <span id="line4045">4045. /* locked, unlocked, broken: box/chest lock states, also door states;</span>
  4050. <span id="line4046">4046. open, closed, doorless: additional door states */</span>
  4051. <span id="line4047">4047. } else if (!strncmpi(d->bp, "locked ", l = 7)) {</span>
  4052. <span id="line4048">4048. d->locked = d->closed = 1,</span>
  4053. <span id="line4049">4049. d->unlocked = d->broken = d->open = d->doorless = 0;</span>
  4054. <span id="line4050">4050. } else if (!strncmpi(d->bp, "unlocked ", l = 9)) {</span>
  4055. <span id="line4051">4051. d->unlocked = d->closed = 1,</span>
  4056. <span id="line4052">4052. d->locked = d->broken = d->open = d->doorless = 0;</span>
  4057. <span id="line4053">4053. } else if (!strncmpi(d->bp, "broken ", l = 7)) {</span>
  4058. <span id="line4054">4054. d->broken = 1,</span>
  4059. <span id="line4055">4055. d->locked = d->unlocked = d->open = d->closed</span>
  4060. <span id="line4056">4056. = d->doorless = 0;</span>
  4061. <span id="line4057">4057. } else if (!strncmpi(d->bp, "open ", l = 5)) {</span>
  4062. <span id="line4058">4058. d->open = 1,</span>
  4063. <span id="line4059">4059. d->closed = d->locked = d->broken = d->doorless = 0;</span>
  4064. <span id="line4060">4060. } else if (!strncmpi(d->bp, "closed ", l = 7)) {</span>
  4065. <span id="line4061">4061. d->closed = 1,</span>
  4066. <span id="line4062">4062. d->open = d->locked = d->broken = d->doorless = 0;</span>
  4067. <span id="line4063">4063. } else if (!strncmpi(d->bp, "doorless ", l = 9)) {</span>
  4068. <span id="line4064">4064. d->doorless = 1,</span>
  4069. <span id="line4065">4065. d->open = d->closed = d->locked = d->unlocked = d->broken = 0;</span>
  4070. <span id="line4066">4066. /* looted: fountain/sink/throne/tree; disturbed: grave */</span>
  4071. <span id="line4067">4067. } else if (!strncmpi(d->bp, "looted ", l = 7)</span>
  4072. <span id="line4068">4068. /* overload disturbed grave with looted fountain here</span>
  4073. <span id="line4069">4069. even though they're separate in struct rm */</span>
  4074. <span id="line4070">4070. || !strncmpi(d->bp, "disturbed ", l = 10)) {</span>
  4075. <span id="line4071">4071. d->looted = 1;</span>
  4076. <span id="line4072">4072. } else if (!strncmpi(d->bp, "greased ", l = 8)) {</span>
  4077. <span id="line4073">4073. d->isgreased = 1;</span>
  4078. <span id="line4074">4074. } else if (!strncmpi(d->bp, "zombifying ", l = 11)) {</span>
  4079. <span id="line4075">4075. d->zombify = TRUE;</span>
  4080. <span id="line4076">4076. } else if (!strncmpi(d->bp, "very ", l = 5)) {</span>
  4081. <span id="line4077">4077. /* very rusted very heavy iron ball */</span>
  4082. <span id="line4078">4078. d->very = 1;</span>
  4083. <span id="line4079">4079. } else if (!strncmpi(d->bp, "thoroughly ", l = 11)) {</span>
  4084. <span id="line4080">4080. d->very = 2;</span>
  4085. <span id="line4081">4081. } else if (!strncmpi(d->bp, "rusty ", l = 6)</span>
  4086. <span id="line4082">4082. || !strncmpi(d->bp, "rusted ", l = 7)</span>
  4087. <span id="line4083">4083. || !strncmpi(d->bp, "burnt ", l = 6)</span>
  4088. <span id="line4084">4084. || !strncmpi(d->bp, "burned ", l = 7)</span>
  4089. <span id="line4085">4085. || !strncmpi(d->bp, "cracked ", l = 8)) {</span>
  4090. <span id="line4086">4086. d->eroded = 1 + d->very;</span>
  4091. <span id="line4087">4087. d->very = 0;</span>
  4092. <span id="line4088">4088. } else if (!strncmpi(d->bp, "corroded ", l = 9)</span>
  4093. <span id="line4089">4089. || !strncmpi(d->bp, "rotted ", l = 7)) {</span>
  4094. <span id="line4090">4090. d->eroded2 = 1 + d->very;</span>
  4095. <span id="line4091">4091. d->very = 0;</span>
  4096. <span id="line4092">4092. } else if (!strncmpi(d->bp, "partly eaten ", l = 13)</span>
  4097. <span id="line4093">4093. || !strncmpi(d->bp, "partially eaten ", l = 16)) {</span>
  4098. <span id="line4094">4094. d->halfeaten = 1;</span>
  4099. <span id="line4095">4095. } else if (!strncmpi(d->bp, "historic ", l = 9)) {</span>
  4100. <span id="line4096">4096. d->ishistoric = 1;</span>
  4101. <span id="line4097">4097. } else if (!strncmpi(d->bp, "diluted ", l = 8)) {</span>
  4102. <span id="line4098">4098. d->isdiluted = 1;</span>
  4103. <span id="line4099">4099. } else if (!strncmpi(d->bp, "empty ", l = 6)) {</span>
  4104. <span id="line4100">4100. d->contents = TIN_EMPTY;</span>
  4105. <span id="line4101">4101. } else if (!strncmpi(d->bp, "small ", l = 6)) { /* glob sizes */</span>
  4106. <span id="line4102">4102. /* "small" might be part of monster name (mimic, if wishing</span>
  4107. <span id="line4103">4103. for its corpse) rather than prefix for glob size; when</span>
  4108. <span id="line4104">4104. used for globs, it might be either "small glob of <foo>" or</span>
  4109. <span id="line4105">4105. "small <foo> glob" and user might add 's' even though plural</span>
  4110. <span id="line4106">4106. doesn't accomplish anything because globs don't stack */</span>
  4111. <span id="line4107">4107. if (strncmpi(d->bp + l, "glob", 4) && !strstri(d->bp + l, " glob"))</span>
  4112. <span id="line4108">4108. break;</span>
  4113. <span id="line4109">4109. d->gsize = 1;</span>
  4114. <span id="line4110">4110. } else if (!strncmpi(d->bp, "medium ", l = 7)) {</span>
  4115. <span id="line4111">4111. /* 5.0: in 3.6, "medium" was only used during wishing and the</span>
  4116. <span id="line4112">4112. mid-size glob had no adjective when formatted, but as of</span>
  4117. <span id="line4113">4113. 5.0, "medium" has become an explicit part of the name for</span>
  4118. <span id="line4114">4114. combined globs of at least 5 individual ones (owt >= 100)</span>
  4119. <span id="line4115">4115. and less than 15 (owt < 300) */</span>
  4120. <span id="line4116">4116. d->gsize = 2;</span>
  4121. <span id="line4117">4117. } else if (!strncmpi(d->bp, "large ", l = 6)) {</span>
  4122. <span id="line4118">4118. /* "large" might be part of monster name (dog, cat, kobold,</span>
  4123. <span id="line4119">4119. mimic) or object name (box, round shield) rather than</span>
  4124. <span id="line4120">4120. prefix for glob size */</span>
  4125. <span id="line4121">4121. if (strncmpi(d->bp + l, "glob", 4) && !strstri(d->bp + l, " glob"))</span>
  4126. <span id="line4122">4122. break;</span>
  4127. <span id="line4123">4123. /* "very large " had "very " peeled off on previous iteration */</span>
  4128. <span id="line4124">4124. d->gsize = (d->very != 1) ? 3 : 4;</span>
  4129. <span id="line4125">4125. } else if (!strncmpi(d->bp, "real ", l = 5)) {</span>
  4130. <span id="line4126">4126. /* accept "real Amulet of Yendor" with "blessed" or "cursed"</span>
  4131. <span id="line4127">4127. or useless "erodeproof" before or after "real" ... */</span>
  4132. <span id="line4128">4128. d->real = 1; /* don't negate 'fake' here; "real fake amulet" and</span>
  4133. <span id="line4129">4129. * "fake real amulet" will both yield fake amulet</span>
  4134. <span id="line4130">4130. * (so will "real amulet" outside of wizard mode) */</span>
  4135. <span id="line4131">4131. } else if (!strncmpi(d->bp, "fake ", l = 5)) {</span>
  4136. <span id="line4132">4132. /* ... and "fake Amulet of Yendor" likewise */</span>
  4137. <span id="line4133">4133. d->fake = 1, d->real = 0;</span>
  4138. <span id="line4134">4134. /* ['real' isn't actually needed (unless we someday add</span>
  4139. <span id="line4135">4135. "real gem" for random non-glass, non-stone)] */</span>
  4140. <span id="line4136">4136. } else if (!strncmpi(d->bp, "female ", l = 7)) {</span>
  4141. <span id="line4137">4137. d->mgend = FEMALE;</span>
  4142. <span id="line4138">4138. /* if after "corpse/statue/figurine of", remove from string */</span>
  4143. <span id="line4139">4139. if (save_bp)</span>
  4144. <span id="line4140">4140. strsubst(d->bp, "female ", ""), l = 0;</span>
  4145. <span id="line4141">4141. } else if (!strncmpi(d->bp, "male ", l = 5)) {</span>
  4146. <span id="line4142">4142. d->mgend = MALE;</span>
  4147. <span id="line4143">4143. if (save_bp)</span>
  4148. <span id="line4144">4144. strsubst(d->bp, "male ", ""), l = 0;</span>
  4149. <span id="line4145">4145. } else if (!strncmpi(d->bp, "neuter ", l = 7)) {</span>
  4150. <span id="line4146">4146. d->mgend = NEUTRAL;</span>
  4151. <span id="line4147">4147. if (save_bp)</span>
  4152. <span id="line4148">4148. strsubst(d->bp, "neuter ", ""), l = 0;</span>
  4153. <span id="line4149">4149. </span>
  4154. <span id="line4150">4150. /*</span>
  4155. <span id="line4151">4151. * Corpse/statue/figurine gender hack: in order to accept</span>
  4156. <span id="line4152">4152. * "statue of a female gnome ruler" for gnome queen we need</span>
  4157. <span id="line4153">4153. * to recognize and skip over "statue of [a ]". Otherwise</span>
  4158. <span id="line4154">4154. * we would only accept "female gnome ruler statue" and the</span>
  4159. <span id="line4155">4155. * viable but silly "female statue of a gnome ruler".</span>
  4160. <span id="line4156">4156. */</span>
  4161. <span id="line4157">4157. } else if ((!strncmpi(d->bp, "corpse ", l = 7)</span>
  4162. <span id="line4158">4158. || !strncmpi(d->bp, "statue ", l = 7)</span>
  4163. <span id="line4159">4159. || !strncmpi(d->bp, "figurine ", l = 9))</span>
  4164. <span id="line4160">4160. && !strncmpi(d->bp + l, "of ", more_l = 3)) {</span>
  4165. <span id="line4161">4161. save_bp = d->bp; /* we'll backtrack to here later */</span>
  4166. <span id="line4162">4162. l += more_l, more_l = 0;</span>
  4167. <span id="line4163">4163. if (!strncmpi(d->bp + l, "a ", more_l = 2)</span>
  4168. <span id="line4164">4164. || !strncmpi(d->bp + l, "an ", more_l = 3)</span>
  4169. <span id="line4165">4165. || !strncmpi(d->bp + l, "the ", more_l = 4))</span>
  4170. <span id="line4166">4166. l += more_l;</span>
  4171. <span id="line4167">4167. } else {</span>
  4172. <span id="line4168">4168. break;</span>
  4173. <span id="line4169">4169. }</span>
  4174. <span id="line4170">4170. d->bp += l;</span>
  4175. <span id="line4171">4171. }</span>
  4176. <span id="line4172">4172. if (save_bp)</span>
  4177. <span id="line4173">4173. d->bp = save_bp;</span>
  4178. <span id="line4174">4174. return res;</span>
  4179. <span id="line4175">4175. }</span>
  4180. <span id="line4176">4176. </span>
  4181. <span id="line4177">4177. staticfn void</span>
  4182. <span id="line4178">4178. readobjnam_parse_charges(struct _readobjnam_data *d)</span>
  4183. <span id="line4179">4179. {</span>
  4184. <span id="line4180">4180. if (strlen(d->bp) > 1 && (d->p = strrchr(d->bp, '(')) != 0) {</span>
  4185. <span id="line4181">4181. boolean keeptrailingchars = TRUE;</span>
  4186. <span id="line4182">4182. int idx = 0;</span>
  4187. <span id="line4183">4183. </span>
  4188. <span id="line4184">4184. if (d->p > d->bp && d->p[-1] == ' ')</span>
  4189. <span id="line4185">4185. idx = -1;</span>
  4190. <span id="line4186">4186. d->p[idx] = '\0'; /* terminate bp */</span>
  4191. <span id="line4187">4187. ++d->p; /* advance past '(' */</span>
  4192. <span id="line4188">4188. if (!strncmpi(d->p, "lit)", 4)) {</span>
  4193. <span id="line4189">4189. d->islit = 1;</span>
  4194. <span id="line4190">4190. d->p += 4 - 1; /* point at ')' */</span>
  4195. <span id="line4191">4191. } else {</span>
  4196. <span id="line4192">4192. d->spe = atoi(d->p);</span>
  4197. <span id="line4193">4193. while (digit(*d->p))</span>
  4198. <span id="line4194">4194. d->p++;</span>
  4199. <span id="line4195">4195. if (*d->p == ':') {</span>
  4200. <span id="line4196">4196. d->p++;</span>
  4201. <span id="line4197">4197. d->rechrg = d->spe;</span>
  4202. <span id="line4198">4198. d->spe = atoi(d->p);</span>
  4203. <span id="line4199">4199. while (digit(*d->p))</span>
  4204. <span id="line4200">4200. d->p++;</span>
  4205. <span id="line4201">4201. }</span>
  4206. <span id="line4202">4202. if (*d->p != ')') {</span>
  4207. <span id="line4203">4203. d->spe = d->rechrg = 0;</span>
  4208. <span id="line4204">4204. /* mis-matched parentheses; rest of string will be ignored</span>
  4209. <span id="line4205">4205. * [probably we should restore everything back to '('</span>
  4210. <span id="line4206">4206. * instead since it might be part of "named ..."]</span>
  4211. <span id="line4207">4207. */</span>
  4212. <span id="line4208">4208. keeptrailingchars = FALSE;</span>
  4213. <span id="line4209">4209. } else {</span>
  4214. <span id="line4210">4210. d->spesgn = 1;</span>
  4215. <span id="line4211">4211. }</span>
  4216. <span id="line4212">4212. }</span>
  4217. <span id="line4213">4213. if (keeptrailingchars) {</span>
  4218. <span id="line4214">4214. char *pp = eos(d->bp);</span>
  4219. <span id="line4215">4215. </span>
  4220. <span id="line4216">4216. /* 'pp' points at 'pb's terminating '\0',</span>
  4221. <span id="line4217">4217. 'p' points at ')' and will be incremented past it */</span>
  4222. <span id="line4218">4218. do {</span>
  4223. <span id="line4219">4219. *pp++ = *++d->p;</span>
  4224. <span id="line4220">4220. } while (*d->p);</span>
  4225. <span id="line4221">4221. }</span>
  4226. <span id="line4222">4222. }</span>
  4227. <span id="line4223">4223. /*</span>
  4228. <span id="line4224">4224. * otmp->spe is type schar, so we don't want spe to be any bigger or</span>
  4229. <span id="line4225">4225. * smaller. Also, spe should always be positive --some cheaters may</span>
  4230. <span id="line4226">4226. * try to confuse atoi().</span>
  4231. <span id="line4227">4227. */</span>
  4232. <span id="line4228">4228. if (d->spe < 0) {</span>
  4233. <span id="line4229">4229. d->spesgn = -1; /* cheaters get what they deserve */</span>
  4234. <span id="line4230">4230. d->spe = abs(d->spe);</span>
  4235. <span id="line4231">4231. }</span>
  4236. <span id="line4232">4232. /* cap on obj->spe is independent of (and less than) SCHAR_LIM */</span>
  4237. <span id="line4233">4233. if (d->spe > SPE_LIM)</span>
  4238. <span id="line4234">4234. d->spe = SPE_LIM; /* slime mold uses d.ftype, so not affected */</span>
  4239. <span id="line4235">4235. if (d->rechrg < 0 || d->rechrg > 7)</span>
  4240. <span id="line4236">4236. d->rechrg = 7; /* recharge_limit */</span>
  4241. <span id="line4237">4237. }</span>
  4242. <span id="line4238">4238. </span>
  4243. <span id="line4239">4239. staticfn int</span>
  4244. <span id="line4240">4240. readobjnam_postparse1(struct _readobjnam_data *d)</span>
  4245. <span id="line4241">4241. {</span>
  4246. <span id="line4242">4242. int i;</span>
  4247. <span id="line4243">4243. </span>
  4248. <span id="line4244">4244. /* now we have the actual name, as delivered by xname, say</span>
  4249. <span id="line4245">4245. * green potions called whisky</span>
  4250. <span id="line4246">4246. * scrolls labeled "QWERTY"</span>
  4251. <span id="line4247">4247. * egg</span>
  4252. <span id="line4248">4248. * fortune cookies</span>
  4253. <span id="line4249">4249. * very heavy iron ball named hoei</span>
  4254. <span id="line4250">4250. * wand of wishing</span>
  4255. <span id="line4251">4251. * elven cloak</span>
  4256. <span id="line4252">4252. */</span>
  4257. <span id="line4253">4253. if ((d->p = strstri(d->bp, " named ")) != 0) {</span>
  4258. <span id="line4254">4254. *d->p = 0;</span>
  4259. <span id="line4255">4255. /* note: if 'name' is too long, oname() will truncate it */</span>
  4260. <span id="line4256">4256. d->name = d->p + 7;</span>
  4261. <span id="line4257">4257. }</span>
  4262. <span id="line4258">4258. if ((d->p = strstri(d->bp, " called ")) != 0) {</span>
  4263. <span id="line4259">4259. *d->p = 0;</span>
  4264. <span id="line4260">4260. /* note: if 'un' is too long, obj lookup just won't match anything */</span>
  4265. <span id="line4261">4261. d->un = d->p + 8;</span>
  4266. <span id="line4262">4262. /* "helmet called telepathy" is not "helmet" (a specific type)</span>
  4267. <span id="line4263">4263. * "shield called reflection" is not "shield" (a general type)</span>
  4268. <span id="line4264">4264. */</span>
  4269. <span id="line4265">4265. for (i = 0; i < SIZE(o_ranges); i++)</span>
  4270. <span id="line4266">4266. if (!strcmpi(d->bp, o_ranges[i].name)) {</span>
  4271. <span id="line4267">4267. d->oclass = o_ranges[i].oclass;</span>
  4272. <span id="line4268">4268. return 1; /*goto srch;*/</span>
  4273. <span id="line4269">4269. }</span>
  4274. <span id="line4270">4270. }</span>
  4275. <span id="line4271">4271. if ((d->p = strstri(d->bp, " labeled ")) != 0) {</span>
  4276. <span id="line4272">4272. *d->p = 0;</span>
  4277. <span id="line4273">4273. d->dn = d->p + 9;</span>
  4278. <span id="line4274">4274. } else if ((d->p = strstri(d->bp, " labelled ")) != 0) {</span>
  4279. <span id="line4275">4275. *d->p = 0;</span>
  4280. <span id="line4276">4276. d->dn = d->p + 10;</span>
  4281. <span id="line4277">4277. }</span>
  4282. <span id="line4278">4278. if ((d->p = strstri(d->bp, " of spinach")) != 0) {</span>
  4283. <span id="line4279">4279. *d->p = 0;</span>
  4284. <span id="line4280">4280. d->contents = TIN_SPINACH;</span>
  4285. <span id="line4281">4281. }</span>
  4286. <span id="line4282">4282. /* real vs fake is only useful for wizard mode but we'll accept its</span>
  4287. <span id="line4283">4283. parsing in normal play (result is never real Amulet for that case) */</span>
  4288. <span id="line4284">4284. if ((d->p = strstri(d->bp, OBJ_DESCR(objects[AMULET_OF_YENDOR]))) != 0</span>
  4289. <span id="line4285">4285. && (d->p == d->bp || d->p[-1] == ' ')) {</span>
  4290. <span id="line4286">4286. char *s = d->bp;</span>
  4291. <span id="line4287">4287. </span>
  4292. <span id="line4288">4288. /* "Amulet of Yendor" matches two items, name of real Amulet</span>
  4293. <span id="line4289">4289. and description of fake one; player can explicitly specify</span>
  4294. <span id="line4290">4290. "real" to disambiguate, but not specifying "fake" achieves</span>
  4295. <span id="line4291">4291. the same thing; "real" and "fake" are parsed above with other</span>
  4296. <span id="line4292">4292. prefixes so that combinations like "blessed real" and "real</span>
  4297. <span id="line4293">4293. blessed" work as expected; also accept partial specification</span>
  4298. <span id="line4294">4294. of the full name of the fake; unlike the prefix recognition</span>
  4299. <span id="line4295">4295. loop above, these have to be in the right order when more</span>
  4300. <span id="line4296">4296. than one is present (similar to worthless glass gems below) */</span>
  4301. <span id="line4297">4297. if (!strncmpi(s, "cheap ", 6))</span>
  4302. <span id="line4298">4298. d->fake = 1, s += 6;</span>
  4303. <span id="line4299">4299. if (!strncmpi(s, "plastic ", 8))</span>
  4304. <span id="line4300">4300. d->fake = 1, s += 8;</span>
  4305. <span id="line4301">4301. if (!strncmpi(s, "imitation ", 10))</span>
  4306. <span id="line4302">4302. d->fake = 1, s += 10;</span>
  4307. <span id="line4303">4303. nhUse(s); /* suppress potential assigned-but-not-used complaint */</span>
  4308. <span id="line4304">4304. /* when 'fake' is True, it overrides 'real' if both were given;</span>
  4309. <span id="line4305">4305. when it is False, force 'real' whether that was specified or not */</span>
  4310. <span id="line4306">4306. d->real = !d->fake;</span>
  4311. <span id="line4307">4307. d->typ = d->real ? AMULET_OF_YENDOR : FAKE_AMULET_OF_YENDOR;</span>
  4312. <span id="line4308">4308. return 2; /*goto typfnd;*/</span>
  4313. <span id="line4309">4309. }</span>
  4314. <span id="line4310">4310. </span>
  4315. <span id="line4311">4311. /*</span>
  4316. <span id="line4312">4312. * Skip over "pair of ", "pairs of", "set of" and "sets of".</span>
  4317. <span id="line4313">4313. *</span>
  4318. <span id="line4314">4314. * Accept "3 pair of boots" as well as "3 pairs of boots". It is</span>
  4319. <span id="line4315">4315. * valid English either way. See makeplural() for more on pair/pairs.</span>
  4320. <span id="line4316">4316. *</span>
  4321. <span id="line4317">4317. * We should only double count if the object in question is not</span>
  4322. <span id="line4318">4318. * referred to as a "pair of". E.g. We should double if the player</span>
  4323. <span id="line4319">4319. * types "pair of spears", but not if the player types "pair of</span>
  4324. <span id="line4320">4320. * lenses". Luckily (?) all objects that are referred to as pairs</span>
  4325. <span id="line4321">4321. * -- boots, gloves, and lenses -- are also not mergeable, so cnt is</span>
  4326. <span id="line4322">4322. * ignored anyway.</span>
  4327. <span id="line4323">4323. */</span>
  4328. <span id="line4324">4324. if (!strncmpi(d->bp, "pair of ", 8)) {</span>
  4329. <span id="line4325">4325. d->bp += 8;</span>
  4330. <span id="line4326">4326. d->cnt *= 2;</span>
  4331. <span id="line4327">4327. } else if (!strncmpi(d->bp, "pairs of ", 9)) {</span>
  4332. <span id="line4328">4328. d->bp += 9;</span>
  4333. <span id="line4329">4329. if (d->cnt > 1)</span>
  4334. <span id="line4330">4330. d->cnt *= 2;</span>
  4335. <span id="line4331">4331. } else if (!strncmpi(d->bp, "set of ", 7)) {</span>
  4336. <span id="line4332">4332. d->bp += 7;</span>
  4337. <span id="line4333">4333. } else if (!strncmpi(d->bp, "sets of ", 8)) {</span>
  4338. <span id="line4334">4334. d->bp += 8;</span>
  4339. <span id="line4335">4335. }</span>
  4340. <span id="line4336">4336. </span>
  4341. <span id="line4337">4337. /* Intercept pudding globs here; they're a valid wish target,</span>
  4342. <span id="line4338">4338. * but we need them to not get treated like a corpse.</span>
  4343. <span id="line4339">4339. * If a count is specified, it will be used to magnify weight</span>
  4344. <span id="line4340">4340. * rather than to specify quantity (which is always 1 for globs).</span>
  4345. <span id="line4341">4341. */</span>
  4346. <span id="line4342">4342. i = (int) strlen(d->bp);</span>
  4347. <span id="line4343">4343. d->p = (char *) 0;</span>
  4348. <span id="line4344">4344. /* check for "glob", "<foo> glob", and "glob of <foo>" */</span>
  4349. <span id="line4345">4345. if (!strcmpi(d->bp, "glob") || !BSTRCMPI(d->bp, d->bp + i - 5, " glob")</span>
  4350. <span id="line4346">4346. || !strcmpi(d->bp, "globs")</span>
  4351. <span id="line4347">4347. || !BSTRCMPI(d->bp, d->bp + i - 6, " globs")</span>
  4352. <span id="line4348">4348. || (d->p = strstri(d->bp, "glob of ")) != 0</span>
  4353. <span id="line4349">4349. || (d->p = strstri(d->bp, "globs of ")) != 0) {</span>
  4354. <span id="line4350">4350. d->mntmp = name_to_mon(!d->p ? d->bp</span>
  4355. <span id="line4351">4351. : (strstri(d->p, " of ") + 4), (int *) 0);</span>
  4356. <span id="line4352">4352. /* if we didn't recognize monster type, pick a valid one at random */</span>
  4357. <span id="line4353">4353. if (d->mntmp == NON_PM)</span>
  4358. <span id="line4354">4354. d->mntmp = rn1(PM_BLACK_PUDDING - PM_GRAY_OOZE, PM_GRAY_OOZE);</span>
  4359. <span id="line4355">4355. /* normally this would be done when makesingular() changes the value</span>
  4360. <span id="line4356">4356. but canonical form here is already singular so that won't happen */</span>
  4361. <span id="line4357">4357. if (d->cnt < 2 && strstri(d->bp, "globs"))</span>
  4362. <span id="line4358">4358. d->cnt = 2; /* affects otmp->owt but not otmp->quan for globs */</span>
  4363. <span id="line4359">4359. /* construct canonical spelling in case name_to_mon() recognized a</span>
  4364. <span id="line4360">4360. variant (grey ooze) or player used inverted syntax (<foo> glob);</span>
  4365. <span id="line4361">4361. if player has given a valid monster type but not valid glob type,</span>
  4366. <span id="line4362">4362. object name lookup won't find it and wish attempt will fail */</span>
  4367. <span id="line4363">4363. Sprintf(d->globbuf, "glob of %s", mons[d->mntmp].pmnames[NEUTRAL]);</span>
  4368. <span id="line4364">4364. d->bp = d->globbuf;</span>
  4369. <span id="line4365">4365. d->mntmp = NON_PM; /* not useful for "glob of <foo>" object lookup */</span>
  4370. <span id="line4366">4366. d->oclass = FOOD_CLASS;</span>
  4371. <span id="line4367">4367. d->actualn = d->bp, d->dn = 0;</span>
  4372. <span id="line4368">4368. return 1; /*goto srch;*/</span>
  4373. <span id="line4369">4369. } else {</span>
  4374. <span id="line4370">4370. /*</span>
  4375. <span id="line4371">4371. * Find corpse type using "of" (figurine of an orc, tin of orc meat)</span>
  4376. <span id="line4372">4372. * Don't check if it's a wand or spellbook.</span>
  4377. <span id="line4373">4373. * (avoid "wand/finger of death" confusion).</span>
  4378. <span id="line4374">4374. * Don't match "ogre" or "giant" monster name inside alternate item</span>
  4379. <span id="line4375">4375. * names "gauntlets of ogre power" and "gauntlets of giant strength"</span>
  4380. <span id="line4376">4376. * (or the alternate spelling of those, "gloves of ...").</span>
  4381. <span id="line4377">4377. */</span>
  4382. <span id="line4378">4378. if (!strstri(d->bp, "wand ") && !strstri(d->bp, "spellbook ")</span>
  4383. <span id="line4379">4379. && !strstri(d->bp, "gauntlets ") && !strstri(d->bp, "gloves ")</span>
  4384. <span id="line4380">4380. && !strstri(d->bp, "finger ")) {</span>
  4385. <span id="line4381">4381. if ((d->p = strstri(d->bp, "tin of ")) != 0) {</span>
  4386. <span id="line4382">4382. if (!strcmpi(d->p + 7, "spinach")) {</span>
  4387. <span id="line4383">4383. d->contents = TIN_SPINACH;</span>
  4388. <span id="line4384">4384. d->mntmp = NON_PM;</span>
  4389. <span id="line4385">4385. } else {</span>
  4390. <span id="line4386">4386. d->tmp = tin_variety_txt(d->p + 7, &d->tinv);</span>
  4391. <span id="line4387">4387. d->tvariety = d->tinv;</span>
  4392. <span id="line4388">4388. d->mntmp = name_to_mon(d->p + 7 + d->tmp, &d->mgend);</span>
  4393. <span id="line4389">4389. }</span>
  4394. <span id="line4390">4390. d->typ = TIN;</span>
  4395. <span id="line4391">4391. return 2; /*goto typfnd;*/</span>
  4396. <span id="line4392">4392. } else if ((d->p = strstri(d->bp, " of ")) != 0</span>
  4397. <span id="line4393">4393. && ((d->mntmp = name_to_mon(d->p + 4, &d->mgend))</span>
  4398. <span id="line4394">4394. >= LOW_PM))</span>
  4399. <span id="line4395">4395. *d->p = 0;</span>
  4400. <span id="line4396">4396. }</span>
  4401. <span id="line4397">4397. }</span>
  4402. <span id="line4398">4398. /* Find corpse type w/o "of" (red dragon scale mail, yeti corpse) */</span>
  4403. <span id="line4399">4399. if (strncmpi(d->bp, "samurai sword", 13) /* not the "samurai" monster! */</span>
  4404. <span id="line4400">4400. && strncmpi(d->bp, "wizard lock", 11) /* not the "wizard" monster! */</span>
  4405. <span id="line4401">4401. && strncmpi(d->bp, "death wand", 10) /* 'of inversion', not Rider */</span>
  4406. <span id="line4402">4402. && strncmpi(d->bp, "master key", 10) /* not the "master" rank */</span>
  4407. <span id="line4403">4403. && strncmpi(d->bp, "ninja-to", 8) /* not the "ninja" rank */</span>
  4408. <span id="line4404">4404. && strncmpi(d->bp, "magenta", 7)) { /* not the "mage" rank */</span>
  4409. <span id="line4405">4405. const char *rest = 0;</span>
  4410. <span id="line4406">4406. </span>
  4411. <span id="line4407">4407. if (d->mntmp < LOW_PM && strlen(d->bp) > 2</span>
  4412. <span id="line4408">4408. && ((d->mntmp = name_to_monplus(d->bp, &rest, &d->mgend))</span>
  4413. <span id="line4409">4409. >= LOW_PM)) {</span>
  4414. <span id="line4410">4410. char *obp = d->bp;</span>
  4415. <span id="line4411">4411. </span>
  4416. <span id="line4412">4412. /* 'rest' is a pointer past the matching portion; if that was</span>
  4417. <span id="line4413">4413. an alternate name or a rank title rather than the canonical</span>
  4418. <span id="line4414">4414. monster name we wouldn't otherwise know how much to skip */</span>
  4419. <span id="line4415">4415. d->bp = (char *) rest; /* cast away const */</span>
  4420. <span id="line4416">4416. </span>
  4421. <span id="line4417">4417. if (*d->bp == ' ') {</span>
  4422. <span id="line4418">4418. d->bp++;</span>
  4423. <span id="line4419">4419. } else if (!strncmpi(d->bp, "s ", 2)</span>
  4424. <span id="line4420">4420. || (d->bp > d->origbp</span>
  4425. <span id="line4421">4421. && !strncmpi(d->bp - 1, "s' ", 3))) {</span>
  4426. <span id="line4422">4422. d->bp += 2;</span>
  4427. <span id="line4423">4423. } else if (!strncmpi(d->bp, "es ", 3)</span>
  4428. <span id="line4424">4424. || !strncmpi(d->bp, "'s ", 3)) {</span>
  4429. <span id="line4425">4425. d->bp += 3;</span>
  4430. <span id="line4426">4426. } else if (!*d->bp && !d->actualn && !d->dn && !d->un</span>
  4431. <span id="line4427">4427. && !d->oclass) {</span>
  4432. <span id="line4428">4428. /* no referent; they don't really mean a monster type */</span>
  4433. <span id="line4429">4429. d->bp = obp;</span>
  4434. <span id="line4430">4430. d->mntmp = NON_PM;</span>
  4435. <span id="line4431">4431. }</span>
  4436. <span id="line4432">4432. }</span>
  4437. <span id="line4433">4433. }</span>
  4438. <span id="line4434">4434. </span>
  4439. <span id="line4435">4435. /* first change to singular if necessary */</span>
  4440. <span id="line4436">4436. if (*d->bp</span>
  4441. <span id="line4437">4437. /* we want "tricks" to match "bag of tricks" [rnd_otyp_by_namedesc()]</span>
  4442. <span id="line4438">4438. but that wouldn't work if it gets singularized to "trick"</span>
  4443. <span id="line4439">4439. ["tricks bag" matches whether or not this exception is present</span>
  4444. <span id="line4440">4440. because singularize operates on "bag" and wishymatch()'s</span>
  4445. <span id="line4441">4441. 'of inversion' finds a match] */</span>
  4446. <span id="line4442">4442. && strcmpi(d->bp, "tricks")</span>
  4447. <span id="line4443">4443. /* an odd potential wish; fail rather than get a false match with</span>
  4448. <span id="line4444">4444. "cloth" because it might yield a "cloth spellbook" rather than</span>
  4449. <span id="line4445">4445. a "piece of cloth" cloak [maybe we should give random armor?] */</span>
  4450. <span id="line4446">4446. && strcmpi(d->bp, "clothes")</span>
  4451. <span id="line4447">4447. ) {</span>
  4452. <span id="line4448">4448. char *sng = makesingular(d->bp);</span>
  4453. <span id="line4449">4449. </span>
  4454. <span id="line4450">4450. if (strcmp(d->bp, sng)) {</span>
  4455. <span id="line4451">4451. if (d->cnt == 1)</span>
  4456. <span id="line4452">4452. d->cnt = 2;</span>
  4457. <span id="line4453">4453. Strcpy(d->bp, sng);</span>
  4458. <span id="line4454">4454. }</span>
  4459. <span id="line4455">4455. }</span>
  4460. <span id="line4456">4456. </span>
  4461. <span id="line4457">4457. /* Alternate spellings (pick-ax, silver sabre, &c) */</span>
  4462. <span id="line4458">4458. {</span>
  4463. <span id="line4459">4459. const struct alt_spellings *as = spellings;</span>
  4464. <span id="line4460">4460. </span>
  4465. <span id="line4461">4461. while (as->sp) {</span>
  4466. <span id="line4462">4462. if (wishymatch(d->bp, as->sp, TRUE)) {</span>
  4467. <span id="line4463">4463. d->typ = as->ob;</span>
  4468. <span id="line4464">4464. return 2; /*goto typfnd;*/</span>
  4469. <span id="line4465">4465. }</span>
  4470. <span id="line4466">4466. as++;</span>
  4471. <span id="line4467">4467. }</span>
  4472. <span id="line4468">4468. /* can't use spellings list for this one due to shuffling */</span>
  4473. <span id="line4469">4469. if (!strncmpi(d->bp, "grey spell", 10))</span>
  4474. <span id="line4470">4470. *(d->bp + 2) = 'a';</span>
  4475. <span id="line4471">4471. </span>
  4476. <span id="line4472">4472. if ((d->p = strstri(d->bp, "armour")) != 0) {</span>
  4477. <span id="line4473">4473. /* skip past "armo", then copy remainder beyond "u" */</span>
  4478. <span id="line4474">4474. d->p += 4;</span>
  4479. <span id="line4475">4475. while ((*d->p = *(d->p + 1)) != '\0')</span>
  4480. <span id="line4476">4476. ++d->p; /* self terminating */</span>
  4481. <span id="line4477">4477. }</span>
  4482. <span id="line4478">4478. }</span>
  4483. <span id="line4479">4479. </span>
  4484. <span id="line4480">4480. /* dragon scales - assumes order of dragons */</span>
  4485. <span id="line4481">4481. if (!strcmpi(d->bp, "scales") && d->mntmp >= PM_GRAY_DRAGON</span>
  4486. <span id="line4482">4482. && d->mntmp <= PM_YELLOW_DRAGON) {</span>
  4487. <span id="line4483">4483. d->typ = GRAY_DRAGON_SCALES + d->mntmp - PM_GRAY_DRAGON;</span>
  4488. <span id="line4484">4484. d->mntmp = NON_PM; /* no monster */</span>
  4489. <span id="line4485">4485. return 2; /*goto typfnd;*/</span>
  4490. <span id="line4486">4486. }</span>
  4491. <span id="line4487">4487. </span>
  4492. <span id="line4488">4488. d->p = eos(d->bp);</span>
  4493. <span id="line4489">4489. if (!BSTRCMPI(d->bp, d->p - 10, "holy water")) {</span>
  4494. <span id="line4490">4490. /* this isn't needed for "[un]holy water" because adjective parsing</span>
  4495. <span id="line4491">4491. handles holy==blessed and unholy==cursed and leaves "water" for</span>
  4496. <span id="line4492">4492. the object type, but it is needed for "potion of [un]holy water"</span>
  4497. <span id="line4493">4493. since that parsing stops when it reaches "potion"; also, neither</span>
  4498. <span id="line4494">4494. "holy water" nor "unholy water" is an actual type of potion */</span>
  4499. <span id="line4495">4495. if (!BSTRNCMPI(d->bp, d->p - 10 - 2, "un", 2))</span>
  4500. <span id="line4496">4496. d->iscursed = 1, d->blessed = d->uncursed = 0; /* unholy water */</span>
  4501. <span id="line4497">4497. else</span>
  4502. <span id="line4498">4498. d->blessed = 1, d->iscursed = d->uncursed = 0; /* holy water */</span>
  4503. <span id="line4499">4499. d->typ = POT_WATER;</span>
  4504. <span id="line4500">4500. return 2; /*goto typfnd;*/</span>
  4505. <span id="line4501">4501. }</span>
  4506. <span id="line4502">4502. /* accept "paperback" or "paperback book", reject "paperback spellbook" */</span>
  4507. <span id="line4503">4503. if (!strncmpi(d->bp, "paperback", 9)) {</span>
  4508. <span id="line4504">4504. char *dbp = d->bp + 9; /* just past "paperback" */</span>
  4509. <span id="line4505">4505. </span>
  4510. <span id="line4506">4506. if (!*dbp || !strncmpi(dbp, " book", 5)) {</span>
  4511. <span id="line4507">4507. d->typ = SPE_NOVEL;</span>
  4512. <span id="line4508">4508. return 2; /*goto typfnd;*/</span>
  4513. <span id="line4509">4509. } else {</span>
  4514. <span id="line4510">4510. d->otmp = (struct obj *) 0;</span>
  4515. <span id="line4511">4511. return 3;</span>
  4516. <span id="line4512">4512. }</span>
  4517. <span id="line4513">4513. }</span>
  4518. <span id="line4514">4514. if (d->unlabeled && !BSTRCMPI(d->bp, d->p - 6, "scroll")) {</span>
  4519. <span id="line4515">4515. d->typ = SCR_BLANK_PAPER;</span>
  4520. <span id="line4516">4516. return 2; /*goto typfnd;*/</span>
  4521. <span id="line4517">4517. }</span>
  4522. <span id="line4518">4518. if (d->unlabeled && !BSTRCMPI(d->bp, d->p - 9, "spellbook")) {</span>
  4523. <span id="line4519">4519. d->typ = SPE_BLANK_PAPER;</span>
  4524. <span id="line4520">4520. return 2; /*goto typfnd;*/</span>
  4525. <span id="line4521">4521. }</span>
  4526. <span id="line4522">4522. /* specific food rather than color of gem/potion/spellbook[/scales] */</span>
  4527. <span id="line4523">4523. if (!BSTRCMPI(d->bp, d->p - 6, "orange") && d->mntmp == NON_PM) {</span>
  4528. <span id="line4524">4524. d->typ = ORANGE;</span>
  4529. <span id="line4525">4525. return 2; /*goto typfnd;*/</span>
  4530. <span id="line4526">4526. }</span>
  4531. <span id="line4527">4527. /*</span>
  4532. <span id="line4528">4528. * NOTE: Gold pieces are handled as objects nowadays, and therefore</span>
  4533. <span id="line4529">4529. * this section should probably be reconsidered as well as the entire</span>
  4534. <span id="line4530">4530. * gold/money concept. Maybe we want to add other monetary units as</span>
  4535. <span id="line4531">4531. * well in the future. (TH)</span>
  4536. <span id="line4532">4532. */</span>
  4537. <span id="line4533">4533. if (!BSTRCMPI(d->bp, d->p - 10, "gold piece")</span>
  4538. <span id="line4534">4534. || !BSTRCMPI(d->bp, d->p - 7, "zorkmid")</span>
  4539. <span id="line4535">4535. || !strcmpi(d->bp, "gold") || !strcmpi(d->bp, "money")</span>
  4540. <span id="line4536">4536. || !strcmpi(d->bp, "coin") || *d->bp == GOLD_SYM) {</span>
  4541. <span id="line4537">4537. if (d->cnt > 5000 && !wizard)</span>
  4542. <span id="line4538">4538. d->cnt = 5000;</span>
  4543. <span id="line4539">4539. else if (d->cnt < 1)</span>
  4544. <span id="line4540">4540. d->cnt = 1;</span>
  4545. <span id="line4541">4541. d->otmp = mksobj(GOLD_PIECE, FALSE, FALSE);</span>
  4546. <span id="line4542">4542. d->otmp->quan = (long) d->cnt;</span>
  4547. <span id="line4543">4543. d->otmp->owt = weight(d->otmp);</span>
  4548. <span id="line4544">4544. disp.botl = TRUE;</span>
  4549. <span id="line4545">4545. return 3; /*return otmp;*/</span>
  4550. <span id="line4546">4546. }</span>
  4551. <span id="line4547">4547. </span>
  4552. <span id="line4548">4548. /* check for single character object class code ("/" for wand, &c) */</span>
  4553. <span id="line4549">4549. if (strlen(d->bp) == 1 && (i = def_char_to_objclass(*d->bp)) < MAXOCLASSES</span>
  4554. <span id="line4550">4550. && i > ILLOBJ_CLASS && (i != VENOM_CLASS || wizard)) {</span>
  4555. <span id="line4551">4551. d->oclass = i;</span>
  4556. <span id="line4552">4552. return 4; /*goto any;*/</span>
  4557. <span id="line4553">4553. }</span>
  4558. <span id="line4554">4554. </span>
  4559. <span id="line4555">4555. /* Search for class names: XXXXX potion, scroll of XXXXX.</span>
  4560. <span id="line4556">4556. Avoid false hits on, e.g., rings for "ring mail". */</span>
  4561. <span id="line4557">4557. if (strncmpi(d->bp, "enchant ", 8)</span>
  4562. <span id="line4558">4558. && strncmpi(d->bp, "destroy ", 8)</span>
  4563. <span id="line4559">4559. && strncmpi(d->bp, "detect food", 11)</span>
  4564. <span id="line4560">4560. && strncmpi(d->bp, "food detection", 14)</span>
  4565. <span id="line4561">4561. && strncmpi(d->bp, "ring mail", 9)</span>
  4566. <span id="line4562">4562. && strncmpi(d->bp, "studded leather armor", 21)</span>
  4567. <span id="line4563">4563. && strncmpi(d->bp, "leather armor", 13)</span>
  4568. <span id="line4564">4564. && strncmpi(d->bp, "tooled horn", 11)</span>
  4569. <span id="line4565">4565. && strncmpi(d->bp, "food ration", 11)</span>
  4570. <span id="line4566">4566. && strncmpi(d->bp, "meat ring", 9))</span>
  4571. <span id="line4567">4567. for (i = 0; i < (int) (sizeof wrpsym); i++) {</span>
  4572. <span id="line4568">4568. int j = Strlen(wrp[i]);</span>
  4573. <span id="line4569">4569. </span>
  4574. <span id="line4570">4570. /* check for "<class> [ of ] something" */</span>
  4575. <span id="line4571">4571. if (!strncmpi(d->bp, wrp[i], j)) {</span>
  4576. <span id="line4572">4572. d->oclass = wrpsym[i];</span>
  4577. <span id="line4573">4573. if (d->oclass != AMULET_CLASS) {</span>
  4578. <span id="line4574">4574. d->bp += j;</span>
  4579. <span id="line4575">4575. if (!strncmpi(d->bp, " of ", 4))</span>
  4580. <span id="line4576">4576. d->actualn = d->bp + 4;</span>
  4581. <span id="line4577">4577. /* else if(*bp) ?? */</span>
  4582. <span id="line4578">4578. } else</span>
  4583. <span id="line4579">4579. d->actualn = d->bp;</span>
  4584. <span id="line4580">4580. return 1; /*goto srch;*/</span>
  4585. <span id="line4581">4581. }</span>
  4586. <span id="line4582">4582. /* check for "something <class>" */</span>
  4587. <span id="line4583">4583. if (!BSTRCMPI(d->bp, d->p - j, wrp[i])) {</span>
  4588. <span id="line4584">4584. d->oclass = wrpsym[i];</span>
  4589. <span id="line4585">4585. /* for "foo amulet", leave the class name so that</span>
  4590. <span id="line4586">4586. wishymatch() can do "of inversion" to try matching</span>
  4591. <span id="line4587">4587. "amulet of foo"; other classes don't include their</span>
  4592. <span id="line4588">4588. class name in their full object names (where</span>
  4593. <span id="line4589">4589. "potion of healing" is just "healing", for instance) */</span>
  4594. <span id="line4590">4590. if (d->oclass != AMULET_CLASS) {</span>
  4595. <span id="line4591">4591. d->p -= j;</span>
  4596. <span id="line4592">4592. *d->p = '\0';</span>
  4597. <span id="line4593">4593. if (d->p > d->bp && d->p[-1] == ' ')</span>
  4598. <span id="line4594">4594. d->p[-1] = '\0';</span>
  4599. <span id="line4595">4595. } else {</span>
  4600. <span id="line4596">4596. int k, l;</span>
  4601. <span id="line4597">4597. char amubuf[BUFSZ];</span>
  4602. <span id="line4598">4598. </span>
  4603. <span id="line4599">4599. /* amulet without "of"; convoluted wording but better a</span>
  4604. <span id="line4600">4600. special case that's handled than one that's missing */</span>
  4605. <span id="line4601">4601. if (!strncmpi(d->bp, "versus poison ", 14)) {</span>
  4606. <span id="line4602">4602. d->typ = AMULET_VERSUS_POISON;</span>
  4607. <span id="line4603">4603. return 2; /*goto typfnd;*/</span>
  4608. <span id="line4604">4604. }</span>
  4609. <span id="line4605">4605. /* check for "<shape> amulet"; strip off trailing</span>
  4610. <span id="line4606">4606. " amulet" for that w/o changing contents of d->bp */</span>
  4611. <span id="line4607">4607. l = (int) strlen(d->bp) - j;</span>
  4612. <span id="line4608">4608. if (l > 0 && d->bp[l - 1] == ' ')</span>
  4613. <span id="line4609">4609. l -= 1;</span>
  4614. <span id="line4610">4610. copynchars(amubuf, d->bp, min(l, (int) sizeof amubuf - 1));</span>
  4615. <span id="line4611">4611. k = rnd_otyp_by_namedesc(amubuf, AMULET_CLASS, 0);</span>
  4616. <span id="line4612">4612. if (k != STRANGE_OBJECT) {</span>
  4617. <span id="line4613">4613. d->typ = k;</span>
  4618. <span id="line4614">4614. return 2; /*goto typfnd;*/</span>
  4619. <span id="line4615">4615. }</span>
  4620. <span id="line4616">4616. }</span>
  4621. <span id="line4617">4617. d->actualn = d->dn = d->bp;</span>
  4622. <span id="line4618">4618. return 1; /*goto srch;*/</span>
  4623. <span id="line4619">4619. }</span>
  4624. <span id="line4620">4620. }</span>
  4625. <span id="line4621">4621. </span>
  4626. <span id="line4622">4622. /* Wishing in wizard mode can create traps and furniture.</span>
  4627. <span id="line4623">4623. * Part I: distinguish between trap and object for the two</span>
  4628. <span id="line4624">4624. * types of traps which have corresponding objects: bear trap</span>
  4629. <span id="line4625">4625. * and land mine. "beartrap" (object) and "bear trap" (trap)</span>
  4630. <span id="line4626">4626. * have a difference in spelling which we used to exploit by</span>
  4631. <span id="line4627">4627. * adding a special case in wishymatch(), but "land mine" is</span>
  4632. <span id="line4628">4628. * spelled the same either way so needs different handing.</span>
  4633. <span id="line4629">4629. * Since we need something else for land mine, we've dropped</span>
  4634. <span id="line4630">4630. * the bear trap hack so that both are handled exactly the</span>
  4635. <span id="line4631">4631. * same. To get an armed trap instead of a disarmed object,</span>
  4636. <span id="line4632">4632. * the player can prefix either the object name or the trap</span>
  4637. <span id="line4633">4633. * name with "trapped " (which ordinarily applies to chests</span>
  4638. <span id="line4634">4634. * and tins), or append something--anything at all except for</span>
  4639. <span id="line4635">4635. * " object", but " trap" is suggested--to either the trap</span>
  4640. <span id="line4636">4636. * name or the object name.</span>
  4641. <span id="line4637">4637. */</span>
  4642. <span id="line4638">4638. if (wizard && (!strncmpi(d->bp, "bear", 4)</span>
  4643. <span id="line4639">4639. || !strncmpi(d->bp, "land", 4))) {</span>
  4644. <span id="line4640">4640. boolean beartrap = (lowc(*d->bp) == 'b');</span>
  4645. <span id="line4641">4641. char *zp = d->bp + 4; /* skip "bear"/"land" */</span>
  4646. <span id="line4642">4642. </span>
  4647. <span id="line4643">4643. if (*zp == ' ')</span>
  4648. <span id="line4644">4644. ++zp; /* embedded space is optional */</span>
  4649. <span id="line4645">4645. if (!strncmpi(zp, beartrap ? "trap" : "mine", 4)) {</span>
  4650. <span id="line4646">4646. zp += 4;</span>
  4651. <span id="line4647">4647. if (d->trapped == 2 || !strcmpi(zp, " object")) {</span>
  4652. <span id="line4648">4648. /* "untrapped <foo>" or "<foo> object" */</span>
  4653. <span id="line4649">4649. d->typ = beartrap ? BEARTRAP : LAND_MINE;</span>
  4654. <span id="line4650">4650. return 2; /*goto typfnd;*/</span>
  4655. <span id="line4651">4651. } else if (d->trapped == 1 || *zp != '\0') {</span>
  4656. <span id="line4652">4652. /* "trapped <foo>" or "<foo> trap" (actually "<foo>*") */</span>
  4657. <span id="line4653">4653. /* use canonical trap spelling, skip object matching */</span>
  4658. <span id="line4654">4654. Strcpy(d->bp, trapname(beartrap ? BEAR_TRAP : LANDMINE, TRUE));</span>
  4659. <span id="line4655">4655. return 5; /*goto wiztrap;*/</span>
  4660. <span id="line4656">4656. }</span>
  4661. <span id="line4657">4657. /* [no prefix or suffix; we're going to end up matching</span>
  4662. <span id="line4658">4658. the object name and getting a disarmed trap object] */</span>
  4663. <span id="line4659">4659. }</span>
  4664. <span id="line4660">4660. }</span>
  4665. <span id="line4661">4661. </span>
  4666. <span id="line4662">4662. return 0;</span>
  4667. <span id="line4663">4663. }</span>
  4668. <span id="line4664">4664. </span>
  4669. <span id="line4665">4665. staticfn int</span>
  4670. <span id="line4666">4666. readobjnam_postparse2(struct _readobjnam_data *d)</span>
  4671. <span id="line4667">4667. {</span>
  4672. <span id="line4668">4668. int i;</span>
  4673. <span id="line4669">4669. </span>
  4674. <span id="line4670">4670. /* "grey stone" check must be before general "stone" */</span>
  4675. <span id="line4671">4671. for (i = 0; i < SIZE(o_ranges); i++)</span>
  4676. <span id="line4672">4672. if (!strcmpi(d->bp, o_ranges[i].name)) {</span>
  4677. <span id="line4673">4673. d->typ = rnd_class(o_ranges[i].f_o_range, o_ranges[i].l_o_range);</span>
  4678. <span id="line4674">4674. return 2; /*goto typfnd;*/</span>
  4679. <span id="line4675">4675. }</span>
  4680. <span id="line4676">4676. </span>
  4681. <span id="line4677">4677. if (!BSTRCMPI(d->bp, d->p - 6, " stone")</span>
  4682. <span id="line4678">4678. || !BSTRCMPI(d->bp, d->p - 4, " gem")) {</span>
  4683. <span id="line4679">4679. d->p[!strcmpi(d->p - 4, " gem") ? -4 : -6] = '\0';</span>
  4684. <span id="line4680">4680. d->oclass = GEM_CLASS;</span>
  4685. <span id="line4681">4681. d->dn = d->actualn = d->bp;</span>
  4686. <span id="line4682">4682. return 1; /*goto srch;*/</span>
  4687. <span id="line4683">4683. } else if (!strcmpi(d->bp, "looking glass")) {</span>
  4688. <span id="line4684">4684. ; /* avoid false hit on "* glass" */</span>
  4689. <span id="line4685">4685. } else if (!BSTRCMPI(d->bp, d->p - 6, " glass")</span>
  4690. <span id="line4686">4686. || !strcmpi(d->bp, "glass")) {</span>
  4691. <span id="line4687">4687. char *s = d->bp;</span>
  4692. <span id="line4688">4688. </span>
  4693. <span id="line4689">4689. /* treat "broken glass" as a non-existent item; since "broken" is</span>
  4694. <span id="line4690">4690. also a chest/box prefix it might have been stripped off above */</span>
  4695. <span id="line4691">4691. if (d->broken || strstri(s, "broken")) {</span>
  4696. <span id="line4692">4692. d->otmp = (struct obj *) 0;</span>
  4697. <span id="line4693">4693. return 3; /* return otmp */</span>
  4698. <span id="line4694">4694. }</span>
  4699. <span id="line4695">4695. if (!strncmpi(s, "worthless ", 10))</span>
  4700. <span id="line4696">4696. s += 10;</span>
  4701. <span id="line4697">4697. if (!strncmpi(s, "piece of ", 9))</span>
  4702. <span id="line4698">4698. s += 9;</span>
  4703. <span id="line4699">4699. if (!strncmpi(s, "colored ", 8))</span>
  4704. <span id="line4700">4700. s += 8;</span>
  4705. <span id="line4701">4701. else if (!strncmpi(s, "coloured ", 9))</span>
  4706. <span id="line4702">4702. s += 9;</span>
  4707. <span id="line4703">4703. if (!strcmpi(s, "glass")) { /* choose random color */</span>
  4708. <span id="line4704">4704. /* 9 different kinds */</span>
  4709. <span id="line4705">4705. d->typ = FIRST_GLASS_GEM + rn2(NUM_GLASS_GEMS);</span>
  4710. <span id="line4706">4706. if (objects[d->typ].oc_class == GEM_CLASS)</span>
  4711. <span id="line4707">4707. return 2; /*goto typfnd;*/</span>
  4712. <span id="line4708">4708. else</span>
  4713. <span id="line4709">4709. d->typ = 0; /* somebody changed objects[]? punt */</span>
  4714. <span id="line4710">4710. } else { /* try to construct canonical form */</span>
  4715. <span id="line4711">4711. char tbuf[BUFSZ];</span>
  4716. <span id="line4712">4712. </span>
  4717. <span id="line4713">4713. Strcpy(tbuf, "worthless piece of ");</span>
  4718. <span id="line4714">4714. Strcat(tbuf, s); /* assume it starts with the color */</span>
  4719. <span id="line4715">4715. Strcpy(d->bp, tbuf);</span>
  4720. <span id="line4716">4716. }</span>
  4721. <span id="line4717">4717. }</span>
  4722. <span id="line4718">4718. </span>
  4723. <span id="line4719">4719. d->actualn = d->bp;</span>
  4724. <span id="line4720">4720. if (!d->dn)</span>
  4725. <span id="line4721">4721. d->dn = d->actualn; /* ex. "skull cap" */</span>
  4726. <span id="line4722">4722. </span>
  4727. <span id="line4723">4723. return 0;</span>
  4728. <span id="line4724">4724. }</span>
  4729. <span id="line4725">4725. </span>
  4730. <span id="line4726">4726. staticfn int</span>
  4731. <span id="line4727">4727. readobjnam_postparse3(struct _readobjnam_data *d)</span>
  4732. <span id="line4728">4728. {</span>
  4733. <span id="line4729">4729. int i;</span>
  4734. <span id="line4730">4730. </span>
  4735. <span id="line4731">4731. /* check real names of gems first */</span>
  4736. <span id="line4732">4732. if (!d->oclass && d->actualn) {</span>
  4737. <span id="line4733">4733. for (i = svb.bases[GEM_CLASS]; i <= LAST_REAL_GEM; i++) {</span>
  4738. <span id="line4734">4734. const char *zn;</span>
  4739. <span id="line4735">4735. </span>
  4740. <span id="line4736">4736. if ((zn = OBJ_NAME(objects[i])) != 0 && !strcmpi(d->actualn, zn)) {</span>
  4741. <span id="line4737">4737. d->typ = i;</span>
  4742. <span id="line4738">4738. return 2; /*goto typfnd;*/</span>
  4743. <span id="line4739">4739. }</span>
  4744. <span id="line4740">4740. }</span>
  4745. <span id="line4741">4741. /* "tin of foo" would be caught above, but plain "tin" has</span>
  4746. <span id="line4742">4742. a random chance of yielding "tin wand" unless we do this */</span>
  4747. <span id="line4743">4743. if (!strcmpi(d->actualn, "tin")) {</span>
  4748. <span id="line4744">4744. d->typ = TIN;</span>
  4749. <span id="line4745">4745. return 2; /*goto typfnd;*/</span>
  4750. <span id="line4746">4746. }</span>
  4751. <span id="line4747">4747. }</span>
  4752. <span id="line4748">4748. </span>
  4753. <span id="line4749">4749. if (((d->typ = rnd_otyp_by_namedesc(d->actualn, d->oclass, 1))</span>
  4754. <span id="line4750">4750. != STRANGE_OBJECT)</span>
  4755. <span id="line4751">4751. || (d->dn != d->actualn</span>
  4756. <span id="line4752">4752. && ((d->typ = rnd_otyp_by_namedesc(d->dn, d->oclass, 1))</span>
  4757. <span id="line4753">4753. != STRANGE_OBJECT))</span>
  4758. <span id="line4754">4754. || ((d->typ = rnd_otyp_by_namedesc(d->un, d->oclass, 1))</span>
  4759. <span id="line4755">4755. != STRANGE_OBJECT)</span>
  4760. <span id="line4756">4756. || (d->origbp != d->actualn</span>
  4761. <span id="line4757">4757. && ((d->typ = rnd_otyp_by_namedesc(d->origbp, d->oclass, 1))</span>
  4762. <span id="line4758">4758. != STRANGE_OBJECT)))</span>
  4763. <span id="line4759">4759. return 2; /*goto typfnd;*/</span>
  4764. <span id="line4760">4760. d->typ = 0;</span>
  4765. <span id="line4761">4761. </span>
  4766. <span id="line4762">4762. if (d->actualn) {</span>
  4767. <span id="line4763">4763. const struct Jitem *j = Japanese_items;</span>
  4768. <span id="line4764">4764. </span>
  4769. <span id="line4765">4765. while (j->item) {</span>
  4770. <span id="line4766">4766. if (!strcmpi(d->actualn, j->name)) {</span>
  4771. <span id="line4767">4767. d->typ = j->item;</span>
  4772. <span id="line4768">4768. return 2; /*goto typfnd;*/</span>
  4773. <span id="line4769">4769. }</span>
  4774. <span id="line4770">4770. j++;</span>
  4775. <span id="line4771">4771. }</span>
  4776. <span id="line4772">4772. }</span>
  4777. <span id="line4773">4773. /* if we've stripped off "armor" and failed to match anything</span>
  4778. <span id="line4774">4774. in objects[], append "mail" and try again to catch misnamed</span>
  4779. <span id="line4775">4775. requests like "plate armor" and "yellow dragon scale armor" */</span>
  4780. <span id="line4776">4776. if (d->oclass == ARMOR_CLASS && !strstri(d->bp, "mail")) {</span>
  4781. <span id="line4777">4777. /* modifying bp's string is ok; we're about to resort</span>
  4782. <span id="line4778">4778. to random armor if this also fails to match anything */</span>
  4783. <span id="line4779">4779. Strcat(d->bp, " mail");</span>
  4784. <span id="line4780">4780. return 6; /*goto retry;*/</span>
  4785. <span id="line4781">4781. }</span>
  4786. <span id="line4782">4782. if (!strcmpi(d->bp, "spinach")) {</span>
  4787. <span id="line4783">4783. d->contents = TIN_SPINACH;</span>
  4788. <span id="line4784">4784. d->typ = TIN;</span>
  4789. <span id="line4785">4785. return 2; /*goto typfnd;*/</span>
  4790. <span id="line4786">4786. }</span>
  4791. <span id="line4787">4787. /* Fruits must not mess up the ability to wish for real objects (since</span>
  4792. <span id="line4788">4788. * you can leave a fruit in a bones file and it will be added to</span>
  4793. <span id="line4789">4789. * another person's game), so they must be checked for last, after</span>
  4794. <span id="line4790">4790. * stripping all the possible prefixes and seeing if there's a real</span>
  4795. <span id="line4791">4791. * name in there. So we have to save the full original name. However,</span>
  4796. <span id="line4792">4792. * it's still possible to do things like "uncursed burnt Alaska",</span>
  4797. <span id="line4793">4793. * or worse yet, "2 burned 5 course meals", so we need to loop to</span>
  4798. <span id="line4794">4794. * strip off the prefixes again, this time stripping only the ones</span>
  4799. <span id="line4795">4795. * possible on food.</span>
  4800. <span id="line4796">4796. * We could get even more detailed so as to allow food names with</span>
  4801. <span id="line4797">4797. * prefixes that _are_ possible on food, so you could wish for</span>
  4802. <span id="line4798">4798. * "2 3 alarm chilis". Currently this isn't allowed; options.c</span>
  4803. <span id="line4799">4799. * automatically sticks 'candied' in front of such names.</span>
  4804. <span id="line4800">4800. */</span>
  4805. <span id="line4801">4801. /* Note: not strcmpi. 2 fruits, one capital, one not, are possible.</span>
  4806. <span id="line4802">4802. Also not strncmp. We used to ignore trailing text with it, but</span>
  4807. <span id="line4803">4803. that resulted in "grapefruit" matching "grape" if the latter came</span>
  4808. <span id="line4804">4804. earlier than the former in the fruit list. */</span>
  4809. <span id="line4805">4805. {</span>
  4810. <span id="line4806">4806. char *fp;</span>
  4811. <span id="line4807">4807. int l, cntf;</span>
  4812. <span id="line4808">4808. int blessedf, iscursedf, uncursedf, halfeatenf;</span>
  4813. <span id="line4809">4809. struct fruit *f;</span>
  4814. <span id="line4810">4810. </span>
  4815. <span id="line4811">4811. blessedf = iscursedf = uncursedf = halfeatenf = 0;</span>
  4816. <span id="line4812">4812. cntf = 0;</span>
  4817. <span id="line4813">4813. </span>
  4818. <span id="line4814">4814. fp = d->fruitbuf;</span>
  4819. <span id="line4815">4815. for (;;) {</span>
  4820. <span id="line4816">4816. if (!fp || !*fp)</span>
  4821. <span id="line4817">4817. break;</span>
  4822. <span id="line4818">4818. if (!strncmpi(fp, "an ", l = 3) || !strncmpi(fp, "a ", l = 2)) {</span>
  4823. <span id="line4819">4819. cntf = 1;</span>
  4824. <span id="line4820">4820. } else if (!cntf && digit(*fp)) {</span>
  4825. <span id="line4821">4821. cntf = atoi(fp);</span>
  4826. <span id="line4822">4822. while (digit(*fp))</span>
  4827. <span id="line4823">4823. fp++;</span>
  4828. <span id="line4824">4824. while (*fp == ' ')</span>
  4829. <span id="line4825">4825. fp++;</span>
  4830. <span id="line4826">4826. l = 0;</span>
  4831. <span id="line4827">4827. } else if (!strncmpi(fp, "blessed ", l = 8)) {</span>
  4832. <span id="line4828">4828. blessedf = 1;</span>
  4833. <span id="line4829">4829. } else if (!strncmpi(fp, "cursed ", l = 7)) {</span>
  4834. <span id="line4830">4830. iscursedf = 1;</span>
  4835. <span id="line4831">4831. } else if (!strncmpi(fp, "uncursed ", l = 9)) {</span>
  4836. <span id="line4832">4832. uncursedf = 1;</span>
  4837. <span id="line4833">4833. } else if (!strncmpi(fp, "partly eaten ", l = 13)</span>
  4838. <span id="line4834">4834. || !strncmpi(fp, "partially eaten ", l = 16)) {</span>
  4839. <span id="line4835">4835. halfeatenf = 1;</span>
  4840. <span id="line4836">4836. } else</span>
  4841. <span id="line4837">4837. break;</span>
  4842. <span id="line4838">4838. fp += l;</span>
  4843. <span id="line4839">4839. }</span>
  4844. <span id="line4840">4840. </span>
  4845. <span id="line4841">4841. for (f = gf.ffruit; f; f = f->nextf) {</span>
  4846. <span id="line4842">4842. /* match type: 0=none, 1=exact, 2=singular, 3=plural */</span>
  4847. <span id="line4843">4843. int ftyp = 0;</span>
  4848. <span id="line4844">4844. </span>
  4849. <span id="line4845">4845. if (!strcmp(fp, f->fname))</span>
  4850. <span id="line4846">4846. ftyp = 1;</span>
  4851. <span id="line4847">4847. else if (!strcmp(fp, makesingular(f->fname)))</span>
  4852. <span id="line4848">4848. ftyp = 2;</span>
  4853. <span id="line4849">4849. else if (!strcmp(fp, makeplural(f->fname)))</span>
  4854. <span id="line4850">4850. ftyp = 3;</span>
  4855. <span id="line4851">4851. if (ftyp) {</span>
  4856. <span id="line4852">4852. d->typ = SLIME_MOLD;</span>
  4857. <span id="line4853">4853. d->blessed = blessedf;</span>
  4858. <span id="line4854">4854. d->iscursed = iscursedf;</span>
  4859. <span id="line4855">4855. d->uncursed = uncursedf;</span>
  4860. <span id="line4856">4856. d->halfeaten = halfeatenf;</span>
  4861. <span id="line4857">4857. /* adjust count if user explicitly asked for</span>
  4862. <span id="line4858">4858. singular amount (can't happen unless fruit</span>
  4863. <span id="line4859">4859. has been given an already pluralized name)</span>
  4864. <span id="line4860">4860. or for plural amount */</span>
  4865. <span id="line4861">4861. if (ftyp == 2 && !cntf)</span>
  4866. <span id="line4862">4862. cntf = 1;</span>
  4867. <span id="line4863">4863. else if (ftyp == 3 && !cntf)</span>
  4868. <span id="line4864">4864. cntf = 2;</span>
  4869. <span id="line4865">4865. d->cnt = cntf;</span>
  4870. <span id="line4866">4866. d->ftype = f->fid;</span>
  4871. <span id="line4867">4867. return 2; /*goto typfnd;*/</span>
  4872. <span id="line4868">4868. }</span>
  4873. <span id="line4869">4869. }</span>
  4874. <span id="line4870">4870. }</span>
  4875. <span id="line4871">4871. </span>
  4876. <span id="line4872">4872. if (!d->oclass && d->actualn) {</span>
  4877. <span id="line4873">4873. short objtyp;</span>
  4878. <span id="line4874">4874. </span>
  4879. <span id="line4875">4875. /* Perhaps it's an artifact specified by name, not type */</span>
  4880. <span id="line4876">4876. d->name = artifact_name(d->actualn, &objtyp, TRUE);</span>
  4881. <span id="line4877">4877. if (d->name) {</span>
  4882. <span id="line4878">4878. d->typ = objtyp;</span>
  4883. <span id="line4879">4879. return 2; /*goto typfnd;*/</span>
  4884. <span id="line4880">4880. }</span>
  4885. <span id="line4881">4881. }</span>
  4886. <span id="line4882">4882. </span>
  4887. <span id="line4883">4883. /* got a class, but not specific type;</span>
  4888. <span id="line4884">4884. check alternate spellings of items with matching classes */</span>
  4889. <span id="line4885">4885. if (d->oclass && !d->typ) {</span>
  4890. <span id="line4886">4886. const struct alt_spellings *as = spellings;</span>
  4891. <span id="line4887">4887. </span>
  4892. <span id="line4888">4888. while (as->sp) {</span>
  4893. <span id="line4889">4889. if (objects[as->ob].oc_class == d->oclass</span>
  4894. <span id="line4890">4890. && wishymatch(d->bp, as->sp, TRUE)) {</span>
  4895. <span id="line4891">4891. d->typ = as->ob;</span>
  4896. <span id="line4892">4892. return 2; /*goto typfnd;*/</span>
  4897. <span id="line4893">4893. }</span>
  4898. <span id="line4894">4894. as++;</span>
  4899. <span id="line4895">4895. }</span>
  4900. <span id="line4896">4896. }</span>
  4901. <span id="line4897">4897. </span>
  4902. <span id="line4898">4898. return 0;</span>
  4903. <span id="line4899">4899. }</span>
  4904. <span id="line4900">4900. </span>
  4905. <span id="line4901">4901. </span>
  4906. <span id="line4902">4902. /*</span>
  4907. <span id="line4903">4903. * Return something wished for. Specifying a null pointer for</span>
  4908. <span id="line4904">4904. * the user request string results in a random object. Otherwise,</span>
  4909. <span id="line4905">4905. * if asking explicitly for "nothing" (or "nil") return no_wish;</span>
  4910. <span id="line4906">4906. * if not an object return &hands_obj; if an error (no matching object),</span>
  4911. <span id="line4907">4907. * return null.</span>
  4912. <span id="line4908">4908. */</span>
  4913. <span id="line4909">4909. struct obj *</span>
  4914. <span id="line4910">4910. readobjnam(char *bp, struct obj *no_wish)</span>
  4915. <span id="line4911">4911. {</span>
  4916. <span id="line4912">4912. struct _readobjnam_data d;</span>
  4917. <span id="line4913">4913. </span>
  4918. <span id="line4914">4914. readobjnam_init(bp, &d);</span>
  4919. <span id="line4915">4915. if (!bp)</span>
  4920. <span id="line4916">4916. goto any;</span>
  4921. <span id="line4917">4917. </span>
  4922. <span id="line4918">4918. /* first, remove extra whitespace they may have typed */</span>
  4923. <span id="line4919">4919. (void) mungspaces(bp);</span>
  4924. <span id="line4920">4920. /* allow wishing for "nothing" to preserve wishless conduct...</span>
  4925. <span id="line4921">4921. [now requires "wand of nothing" if that's what was really wanted] */</span>
  4926. <span id="line4922">4922. if (!strcmpi(bp, "nothing") || !strcmpi(bp, "nil")</span>
  4927. <span id="line4923">4923. || !strcmpi(bp, "none"))</span>
  4928. <span id="line4924">4924. return no_wish;</span>
  4929. <span id="line4925">4925. /* save the [nearly] unmodified choice string */</span>
  4930. <span id="line4926">4926. Strcpy(d.fruitbuf, bp);</span>
  4931. <span id="line4927">4927. </span>
  4932. <span id="line4928">4928. if (readobjnam_preparse(&d))</span>
  4933. <span id="line4929">4929. goto any;</span>
  4934. <span id="line4930">4930. </span>
  4935. <span id="line4931">4931. if (!d.cnt)</span>
  4936. <span id="line4932">4932. d.cnt = 1; /* will be changed to 2 if makesingular() changes string */</span>
  4937. <span id="line4933">4933. </span>
  4938. <span id="line4934">4934. readobjnam_parse_charges(&d);</span>
  4939. <span id="line4935">4935. </span>
  4940. <span id="line4936">4936. switch (readobjnam_postparse1(&d)) {</span>
  4941. <span id="line4937">4937. default:</span>
  4942. <span id="line4938">4938. case 0: break;</span>
  4943. <span id="line4939">4939. case 1: goto srch;</span>
  4944. <span id="line4940">4940. case 2: goto typfnd;</span>
  4945. <span id="line4941">4941. case 3: return d.otmp;</span>
  4946. <span id="line4942">4942. case 4: goto any;</span>
  4947. <span id="line4943">4943. case 5: goto wiztrap;</span>
  4948. <span id="line4944">4944. }</span>
  4949. <span id="line4945">4945. </span>
  4950. <span id="line4946">4946. retry:</span>
  4951. <span id="line4947">4947. switch (readobjnam_postparse2(&d)) {</span>
  4952. <span id="line4948">4948. default:</span>
  4953. <span id="line4949">4949. case 0: break;</span>
  4954. <span id="line4950">4950. case 1: goto srch;</span>
  4955. <span id="line4951">4951. case 2: goto typfnd;</span>
  4956. <span id="line4952">4952. case 3: return d.otmp;</span>
  4957. <span id="line4953">4953. case 4: goto any;</span>
  4958. <span id="line4954">4954. case 5: goto wiztrap;</span>
  4959. <span id="line4955">4955. }</span>
  4960. <span id="line4956">4956. </span>
  4961. <span id="line4957">4957. srch:</span>
  4962. <span id="line4958">4958. switch (readobjnam_postparse3(&d)) {</span>
  4963. <span id="line4959">4959. default:</span>
  4964. <span id="line4960">4960. case 0: break;</span>
  4965. <span id="line4961">4961. case 1: goto srch;</span>
  4966. <span id="line4962">4962. case 2: goto typfnd;</span>
  4967. <span id="line4963">4963. case 3: return d.otmp;</span>
  4968. <span id="line4964">4964. case 4: goto any;</span>
  4969. <span id="line4965">4965. case 5: goto wiztrap;</span>
  4970. <span id="line4966">4966. case 6: goto retry;</span>
  4971. <span id="line4967">4967. }</span>
  4972. <span id="line4968">4968. </span>
  4973. <span id="line4969">4969. /*</span>
  4974. <span id="line4970">4970. * Let wizards wish for traps and furniture.</span>
  4975. <span id="line4971">4971. * Must come after objects check so wizards can still wish for</span>
  4976. <span id="line4972">4972. * trap objects like beartraps.</span>
  4977. <span id="line4973">4973. * Disallow such topology tweaks for WIZKIT startup wishes.</span>
  4978. <span id="line4974">4974. */</span>
  4979. <span id="line4975">4975. wiztrap:</span>
  4980. <span id="line4976">4976. if (wizard && !program_state.wizkit_wishing && !d.oclass) {</span>
  4981. <span id="line4977">4977. /* [inline code moved to separate routine to unclutter readobjnam] */</span>
  4982. <span id="line4978">4978. if ((d.otmp = wizterrainwish(&d)) != 0)</span>
  4983. <span id="line4979">4979. return d.otmp;</span>
  4984. <span id="line4980">4980. }</span>
  4985. <span id="line4981">4981. </span>
  4986. <span id="line4982">4982. if (!d.oclass && !d.typ) {</span>
  4987. <span id="line4983">4983. if (!strncmpi(d.bp, "polearm", 7)) {</span>
  4988. <span id="line4984">4984. d.typ = rnd_otyp_by_wpnskill(P_POLEARMS);</span>
  4989. <span id="line4985">4985. goto typfnd;</span>
  4990. <span id="line4986">4986. } else if (!strncmpi(d.bp, "hammer", 6)) {</span>
  4991. <span id="line4987">4987. d.typ = rnd_otyp_by_wpnskill(P_HAMMER);</span>
  4992. <span id="line4988">4988. goto typfnd;</span>
  4993. <span id="line4989">4989. }</span>
  4994. <span id="line4990">4990. }</span>
  4995. <span id="line4991">4991. </span>
  4996. <span id="line4992">4992. if (!d.oclass)</span>
  4997. <span id="line4993">4993. return ((struct obj *) 0);</span>
  4998. <span id="line4994">4994. any:</span>
  4999. <span id="line4995">4995. if (!d.oclass)</span>
  5000. <span id="line4996">4996. d.oclass = wrpsym[rn2((int) sizeof wrpsym)];</span>
  5001. <span id="line4997">4997. typfnd:</span>
  5002. <span id="line4998">4998. if (d.typ)</span>
  5003. <span id="line4999">4999. d.oclass = objects[d.typ].oc_class;</span>
  5004. <span id="line5000">5000. </span>
  5005. <span id="line5001">5001. /* handle some objects that are only allowed in wizard mode */</span>
  5006. <span id="line5002">5002. if (d.typ && !wizard) {</span>
  5007. <span id="line5003">5003. switch (d.typ) {</span>
  5008. <span id="line5004">5004. case AMULET_OF_YENDOR:</span>
  5009. <span id="line5005">5005. d.typ = FAKE_AMULET_OF_YENDOR;</span>
  5010. <span id="line5006">5006. break;</span>
  5011. <span id="line5007">5007. case CANDELABRUM_OF_INVOCATION:</span>
  5012. <span id="line5008">5008. d.typ = rnd_class(TALLOW_CANDLE, WAX_CANDLE);</span>
  5013. <span id="line5009">5009. break;</span>
  5014. <span id="line5010">5010. case BELL_OF_OPENING:</span>
  5015. <span id="line5011">5011. d.typ = BELL;</span>
  5016. <span id="line5012">5012. break;</span>
  5017. <span id="line5013">5013. case SPE_BOOK_OF_THE_DEAD:</span>
  5018. <span id="line5014">5014. d.typ = SPE_BLANK_PAPER;</span>
  5019. <span id="line5015">5015. break;</span>
  5020. <span id="line5016">5016. case MAGIC_LAMP:</span>
  5021. <span id="line5017">5017. d.typ = OIL_LAMP;</span>
  5022. <span id="line5018">5018. break;</span>
  5023. <span id="line5019">5019. default:</span>
  5024. <span id="line5020">5020. /* catch any other non-wishable objects (venom) */</span>
  5025. <span id="line5021">5021. if (objects[d.typ].oc_nowish)</span>
  5026. <span id="line5022">5022. return (struct obj *) 0;</span>
  5027. <span id="line5023">5023. break;</span>
  5028. <span id="line5024">5024. }</span>
  5029. <span id="line5025">5025. }</span>
  5030. <span id="line5026">5026. </span>
  5031. <span id="line5027">5027. /* if asking for corpse of a monster which leaves behind a glob, give</span>
  5032. <span id="line5028">5028. glob instead of rejecting the monster type to create random corpse */</span>
  5033. <span id="line5029">5029. if (d.typ == CORPSE && d.mntmp >= LOW_PM</span>
  5034. <span id="line5030">5030. && mons[d.mntmp].mlet == S_PUDDING) {</span>
  5035. <span id="line5031">5031. d.typ = GLOB_OF_GRAY_OOZE + (d.mntmp - PM_GRAY_OOZE);</span>
  5036. <span id="line5032">5032. d.mntmp = NON_PM; /* not used for globs */</span>
  5037. <span id="line5033">5033. }</span>
  5038. <span id="line5034">5034. /*</span>
  5039. <span id="line5035">5035. * Create the object, then fine-tune it.</span>
  5040. <span id="line5036">5036. */</span>
  5041. <span id="line5037">5037. d.otmp = d.typ ? mksobj(d.typ, TRUE, FALSE) : mkobj(d.oclass, FALSE);</span>
  5042. <span id="line5038">5038. d.typ = d.otmp->otyp, d.oclass = d.otmp->oclass; /* what we actually got */</span>
  5043. <span id="line5039">5039. </span>
  5044. <span id="line5040">5040. /* if player specified a reasonable count, maybe honor it;</span>
  5045. <span id="line5041">5041. quantity for gold is handled elsewhere and d.cnt is 0 for it here */</span>
  5046. <span id="line5042">5042. if (d.otmp->globby) {</span>
  5047. <span id="line5043">5043. /* for globs, calculate weight based on gsize, then multiply by cnt;</span>
  5048. <span id="line5044">5044. asking for 2 globs or for 2 small globs produces 1 small glob</span>
  5049. <span id="line5045">5045. weighing 40au instead of normal 20au; asking for 5 medium globs</span>
  5050. <span id="line5046">5046. might produce 1 very large glob weighing 600au */</span>
  5051. <span id="line5047">5047. d.otmp->quan = 1L; /* always 1 for globs */</span>
  5052. <span id="line5048">5048. d.otmp->owt = weight(d.otmp);</span>
  5053. <span id="line5049">5049. /* gsize 0: unspecified => small;</span>
  5054. <span id="line5050">5050. 1: small (1..5) => keep default owt for 1, yielding 20;</span>
  5055. <span id="line5051">5051. 2: medium (6..15) => use weight for 6, yielding 120;</span>
  5056. <span id="line5052">5052. 3: large (16..25) => 320; 4: very large (26+) => 520 */</span>
  5057. <span id="line5053">5053. if (d.gsize > 1)</span>
  5058. <span id="line5054">5054. d.otmp->owt += ((unsigned) (5 + (d.gsize - 2) * 10)</span>
  5059. <span id="line5055">5055. * d.otmp->owt); /* 20 + {5|15|25} times 20 */</span>
  5060. <span id="line5056">5056. /* limit overall weight which limits shrink-away time which in turn</span>
  5061. <span id="line5057">5057. affects how long some of it will remain available to be eaten */</span>
  5062. <span id="line5058">5058. if (d.cnt > 1) {</span>
  5063. <span id="line5059">5059. int rn1cnt = rn1(5, 2); /* 2..6 */</span>
  5064. <span id="line5060">5060. </span>
  5065. <span id="line5061">5061. if (rn1cnt > 6 - d.gsize)</span>
  5066. <span id="line5062">5062. rn1cnt = 6 - d.gsize;</span>
  5067. <span id="line5063">5063. if (d.cnt > rn1cnt</span>
  5068. <span id="line5064">5064. && (!wizard || program_state.wizkit_wishing</span>
  5069. <span id="line5065">5065. || y_n("Override glob weight limit?") != 'y'))</span>
  5070. <span id="line5066">5066. d.cnt = rn1cnt;</span>
  5071. <span id="line5067">5067. d.otmp->owt *= (unsigned) d.cnt;</span>
  5072. <span id="line5068">5068. }</span>
  5073. <span id="line5069">5069. /* note: the owt assignment below will not change glob's weight */</span>
  5074. <span id="line5070">5070. d.cnt = 0;</span>
  5075. <span id="line5071">5071. } else if (d.cnt > 0) {</span>
  5076. <span id="line5072">5072. if (objects[d.typ].oc_merge</span>
  5077. <span id="line5073">5073. && (wizard /* quantity isn't restricted when debugging */</span>
  5078. <span id="line5074">5074. /* note: in normal play, explicitly asking for 1 might</span>
  5079. <span id="line5075">5075. fail the 'cnt < rnd(6)' test and could produce more</span>
  5080. <span id="line5076">5076. than 1 if mksobj() creates the item that way */</span>
  5081. <span id="line5077">5077. || d.cnt < rnd(6)</span>
  5082. <span id="line5078">5078. || (d.cnt <= 7 && Is_candle(d.otmp))</span>
  5083. <span id="line5079">5079. || (d.cnt <= 20</span>
  5084. <span id="line5080">5080. && (d.typ == ROCK || d.typ == FLINT || is_missile(d.otmp)</span>
  5085. <span id="line5081">5081. /* WEAPON_CLASS test excludes gems, gray stones */</span>
  5086. <span id="line5082">5082. || (d.oclass == WEAPON_CLASS && is_ammo(d.otmp))))))</span>
  5087. <span id="line5083">5083. d.otmp->quan = (long) d.cnt;</span>
  5088. <span id="line5084">5084. }</span>
  5089. <span id="line5085">5085. </span>
  5090. <span id="line5086">5086. if (d.islit && (d.typ == OIL_LAMP || d.typ == MAGIC_LAMP</span>
  5091. <span id="line5087">5087. || d.typ == BRASS_LANTERN</span>
  5092. <span id="line5088">5088. || Is_candle(d.otmp) || d.typ == POT_OIL)) {</span>
  5093. <span id="line5089">5089. place_object(d.otmp, u.ux, u.uy); /* make it viable light source */</span>
  5094. <span id="line5090">5090. begin_burn(d.otmp, FALSE);</span>
  5095. <span id="line5091">5091. obj_extract_self(d.otmp); /* now release it for caller's use */</span>
  5096. <span id="line5092">5092. }</span>
  5097. <span id="line5093">5093. </span>
  5098. <span id="line5094">5094. if (d.spesgn == 0) {</span>
  5099. <span id="line5095">5095. /* spe not specified; retain the randomly assigned value */</span>
  5100. <span id="line5096">5096. d.spe = d.otmp->spe;</span>
  5101. <span id="line5097">5097. } else if (wizard) {</span>
  5102. <span id="line5098">5098. ; /* no restrictions except SPE_LIM */</span>
  5103. <span id="line5099">5099. } else if (d.oclass == ARMOR_CLASS || d.oclass == WEAPON_CLASS</span>
  5104. <span id="line5100">5100. || is_weptool(d.otmp)</span>
  5105. <span id="line5101">5101. || (d.oclass == RING_CLASS && objects[d.typ].oc_charged)) {</span>
  5106. <span id="line5102">5102. if (d.spe > rnd(5) && d.spe > d.otmp->spe)</span>
  5107. <span id="line5103">5103. d.spe = 0;</span>
  5108. <span id="line5104">5104. if (d.spe > 2 && Luck < 0)</span>
  5109. <span id="line5105">5105. d.spesgn = -1;</span>
  5110. <span id="line5106">5106. } else {</span>
  5111. <span id="line5107">5107. /* crystal ball cancels like a wand, to (n:-1) */</span>
  5112. <span id="line5108">5108. if (d.oclass == WAND_CLASS || d.typ == CRYSTAL_BALL) {</span>
  5113. <span id="line5109">5109. if (d.spe > 1 && d.spesgn == -1)</span>
  5114. <span id="line5110">5110. d.spe = 1;</span>
  5115. <span id="line5111">5111. } else {</span>
  5116. <span id="line5112">5112. if (d.spe > 0 && d.spesgn == -1)</span>
  5117. <span id="line5113">5113. d.spe = 0;</span>
  5118. <span id="line5114">5114. }</span>
  5119. <span id="line5115">5115. if (d.spe > d.otmp->spe)</span>
  5120. <span id="line5116">5116. d.spe = d.otmp->spe;</span>
  5121. <span id="line5117">5117. }</span>
  5122. <span id="line5118">5118. </span>
  5123. <span id="line5119">5119. if (d.spesgn == -1)</span>
  5124. <span id="line5120">5120. d.spe = -d.spe;</span>
  5125. <span id="line5121">5121. </span>
  5126. <span id="line5122">5122. /* set otmp->spe. This may, or may not, use d.spe... */</span>
  5127. <span id="line5123">5123. switch (d.typ) {</span>
  5128. <span id="line5124">5124. case TIN:</span>
  5129. <span id="line5125">5125. d.otmp->spe = 0; /* default: not spinach */</span>
  5130. <span id="line5126">5126. if (d.contents == TIN_EMPTY) {</span>
  5131. <span id="line5127">5127. d.otmp->corpsenm = NON_PM;</span>
  5132. <span id="line5128">5128. } else if (d.contents == TIN_SPINACH) {</span>
  5133. <span id="line5129">5129. d.otmp->corpsenm = NON_PM;</span>
  5134. <span id="line5130">5130. d.otmp->spe = 1; /* spinach after all */</span>
  5135. <span id="line5131">5131. }</span>
  5136. <span id="line5132">5132. break;</span>
  5137. <span id="line5133">5133. case TOWEL:</span>
  5138. <span id="line5134">5134. if (d.wetness)</span>
  5139. <span id="line5135">5135. d.otmp->spe = d.wetness;</span>
  5140. <span id="line5136">5136. break;</span>
  5141. <span id="line5137">5137. case SLIME_MOLD:</span>
  5142. <span id="line5138">5138. d.otmp->spe = d.ftype;</span>
  5143. <span id="line5139">5139. FALLTHROUGH;</span>
  5144. <span id="line5140">5140. /* FALLTHRU */</span>
  5145. <span id="line5141">5141. case SKELETON_KEY:</span>
  5146. <span id="line5142">5142. case CHEST:</span>
  5147. <span id="line5143">5143. case LARGE_BOX:</span>
  5148. <span id="line5144">5144. case HEAVY_IRON_BALL:</span>
  5149. <span id="line5145">5145. case IRON_CHAIN:</span>
  5150. <span id="line5146">5146. break;</span>
  5151. <span id="line5147">5147. case STATUE: /* otmp->cobj already done in mksobj() */</span>
  5152. <span id="line5148">5148. case FIGURINE:</span>
  5153. <span id="line5149">5149. case CORPSE: {</span>
  5154. <span id="line5150">5150. struct permonst *P = (ismnum(d.mntmp)) ? &mons[d.mntmp] : 0;</span>
  5155. <span id="line5151">5151. </span>
  5156. <span id="line5152">5152. d.otmp->spe = !P ? CORPSTAT_RANDOM</span>
  5157. <span id="line5153">5153. /* if neuter, force neuter regardless of wish request */</span>
  5158. <span id="line5154">5154. : is_neuter(P) ? CORPSTAT_NEUTER</span>
  5159. <span id="line5155">5155. /* not neuter, honor wish unless it conflicts */</span>
  5160. <span id="line5156">5156. : (d.mgend == FEMALE && !is_male(P)) ? CORPSTAT_FEMALE</span>
  5161. <span id="line5157">5157. : (d.mgend == MALE && !is_female(P)) ? CORPSTAT_MALE</span>
  5162. <span id="line5158">5158. /* unspecified or wish conflicts */</span>
  5163. <span id="line5159">5159. : CORPSTAT_RANDOM;</span>
  5164. <span id="line5160">5160. if (P && d.otmp->spe == CORPSTAT_RANDOM)</span>
  5165. <span id="line5161">5161. d.otmp->spe = is_male(P) ? CORPSTAT_MALE</span>
  5166. <span id="line5162">5162. : is_female(P) ? CORPSTAT_FEMALE</span>
  5167. <span id="line5163">5163. : rn2(2) ? CORPSTAT_MALE : CORPSTAT_FEMALE;</span>
  5168. <span id="line5164">5164. if (d.ishistoric && d.typ == STATUE)</span>
  5169. <span id="line5165">5165. d.otmp->spe |= CORPSTAT_HISTORIC;</span>
  5170. <span id="line5166">5166. break;</span>
  5171. <span id="line5167">5167. };</span>
  5172. <span id="line5168">5168. #ifdef MAIL_STRUCTURES</span>
  5173. <span id="line5169">5169. /* scroll of mail: 0: delivered in-game via external event (or randomly</span>
  5174. <span id="line5170">5170. for fake mail); 1: from bones or wishing; 2: written with marker */</span>
  5175. <span id="line5171">5171. case SCR_MAIL:</span>
  5176. <span id="line5172">5172. d.otmp->spe = 1;</span>
  5177. <span id="line5173">5173. break;</span>
  5178. <span id="line5174">5174. #endif</span>
  5179. <span id="line5175">5175. /* splash of venom: 0: normal, and transitory; 1: wishing */</span>
  5180. <span id="line5176">5176. case ACID_VENOM:</span>
  5181. <span id="line5177">5177. case BLINDING_VENOM:</span>
  5182. <span id="line5178">5178. d.otmp->spe = 1;</span>
  5183. <span id="line5179">5179. break;</span>
  5184. <span id="line5180">5180. case WAN_WISHING:</span>
  5185. <span id="line5181">5181. if (!wizard) {</span>
  5186. <span id="line5182">5182. d.otmp->spe = (rn2(10) ? -1 : 0);</span>
  5187. <span id="line5183">5183. break;</span>
  5188. <span id="line5184">5184. }</span>
  5189. <span id="line5185">5185. FALLTHROUGH;</span>
  5190. <span id="line5186">5186. /*FALLTHRU*/</span>
  5191. <span id="line5187">5187. default:</span>
  5192. <span id="line5188">5188. d.otmp->spe = d.spe;</span>
  5193. <span id="line5189">5189. }</span>
  5194. <span id="line5190">5190. </span>
  5195. <span id="line5191">5191. /* set otmp->corpsenm or dragon scale [mail] */</span>
  5196. <span id="line5192">5192. if (ismnum(d.mntmp)) {</span>
  5197. <span id="line5193">5193. int humanwere;</span>
  5198. <span id="line5194">5194. </span>
  5199. <span id="line5195">5195. if (d.mntmp == PM_LONG_WORM_TAIL)</span>
  5200. <span id="line5196">5196. d.mntmp = PM_LONG_WORM;</span>
  5201. <span id="line5197">5197. /* werecreatures in beast form are all flagged no-corpse so for</span>
  5202. <span id="line5198">5198. corpses and tins, switch to their corresponding human form;</span>
  5203. <span id="line5199">5199. for figurines, override the can't-be-human restriction instead */</span>
  5204. <span id="line5200">5200. if (d.typ != FIGURINE && is_were(&mons[d.mntmp])</span>
  5205. <span id="line5201">5201. && (svm.mvitals[d.mntmp].mvflags & G_NOCORPSE) != 0</span>
  5206. <span id="line5202">5202. && (humanwere = counter_were(d.mntmp)) != NON_PM)</span>
  5207. <span id="line5203">5203. d.mntmp = humanwere;</span>
  5208. <span id="line5204">5204. </span>
  5209. <span id="line5205">5205. switch (d.typ) {</span>
  5210. <span id="line5206">5206. case TIN:</span>
  5211. <span id="line5207">5207. if (dead_species(d.mntmp, FALSE)) {</span>
  5212. <span id="line5208">5208. d.otmp->corpsenm = NON_PM; /* it's empty */</span>
  5213. <span id="line5209">5209. } else if ((!(mons[d.mntmp].geno & G_UNIQ) || wizard)</span>
  5214. <span id="line5210">5210. && !(svm.mvitals[d.mntmp].mvflags & G_NOCORPSE)</span>
  5215. <span id="line5211">5211. && mons[d.mntmp].cnutrit != 0) {</span>
  5216. <span id="line5212">5212. d.otmp->corpsenm = d.mntmp;</span>
  5217. <span id="line5213">5213. }</span>
  5218. <span id="line5214">5214. break;</span>
  5219. <span id="line5215">5215. case CORPSE:</span>
  5220. <span id="line5216">5216. if ((!(mons[d.mntmp].geno & G_UNIQ) || wizard)</span>
  5221. <span id="line5217">5217. && !(svm.mvitals[d.mntmp].mvflags & G_NOCORPSE)) {</span>
  5222. <span id="line5218">5218. if (mons[d.mntmp].msound == MS_GUARDIAN)</span>
  5223. <span id="line5219">5219. d.mntmp = genus(d.mntmp, 1);</span>
  5224. <span id="line5220">5220. set_corpsenm(d.otmp, d.mntmp);</span>
  5225. <span id="line5221">5221. }</span>
  5226. <span id="line5222">5222. if (d.zombify && zombie_form(&mons[d.mntmp])) {</span>
  5227. <span id="line5223">5223. (void) start_timer(rn1(5, 10), TIMER_OBJECT,</span>
  5228. <span id="line5224">5224. ZOMBIFY_MON, obj_to_any(d.otmp));</span>
  5229. <span id="line5225">5225. }</span>
  5230. <span id="line5226">5226. break;</span>
  5231. <span id="line5227">5227. case EGG:</span>
  5232. <span id="line5228">5228. d.mntmp = can_be_hatched(d.mntmp);</span>
  5233. <span id="line5229">5229. /* this also sets hatch timer if appropriate */</span>
  5234. <span id="line5230">5230. set_corpsenm(d.otmp, d.mntmp);</span>
  5235. <span id="line5231">5231. break;</span>
  5236. <span id="line5232">5232. case FIGURINE:</span>
  5237. <span id="line5233">5233. if (!(mons[d.mntmp].geno & G_UNIQ)</span>
  5238. <span id="line5234">5234. && (!is_human(&mons[d.mntmp]) || is_were(&mons[d.mntmp]))</span>
  5239. <span id="line5235">5235. #ifdef MAIL_STRUCTURES</span>
  5240. <span id="line5236">5236. && d.mntmp != PM_MAIL_DAEMON</span>
  5241. <span id="line5237">5237. #endif</span>
  5242. <span id="line5238">5238. )</span>
  5243. <span id="line5239">5239. d.otmp->corpsenm = d.mntmp;</span>
  5244. <span id="line5240">5240. break;</span>
  5245. <span id="line5241">5241. case STATUE:</span>
  5246. <span id="line5242">5242. d.otmp->corpsenm = d.mntmp;</span>
  5247. <span id="line5243">5243. if (Has_contents(d.otmp) && verysmall(&mons[d.mntmp]))</span>
  5248. <span id="line5244">5244. delete_contents(d.otmp); /* no spellbook */</span>
  5249. <span id="line5245">5245. break;</span>
  5250. <span id="line5246">5246. case SCALE_MAIL:</span>
  5251. <span id="line5247">5247. /* Dragon mail - depends on the order of objects & dragons. */</span>
  5252. <span id="line5248">5248. if (d.mntmp >= PM_GRAY_DRAGON && d.mntmp <= PM_YELLOW_DRAGON)</span>
  5253. <span id="line5249">5249. d.otmp->otyp = GRAY_DRAGON_SCALE_MAIL</span>
  5254. <span id="line5250">5250. + d.mntmp - PM_GRAY_DRAGON;</span>
  5255. <span id="line5251">5251. break;</span>
  5256. <span id="line5252">5252. }</span>
  5257. <span id="line5253">5253. }</span>
  5258. <span id="line5254">5254. </span>
  5259. <span id="line5255">5255. /* set blessed/cursed -- setting the fields directly is safe</span>
  5260. <span id="line5256">5256. * since weight() is called below and addinv() will take care</span>
  5261. <span id="line5257">5257. * of luck */</span>
  5262. <span id="line5258">5258. if (d.iscursed) {</span>
  5263. <span id="line5259">5259. curse(d.otmp);</span>
  5264. <span id="line5260">5260. } else if (d.uncursed) {</span>
  5265. <span id="line5261">5261. d.otmp->blessed = 0;</span>
  5266. <span id="line5262">5262. d.otmp->cursed = (Luck < 0 && !wizard);</span>
  5267. <span id="line5263">5263. } else if (d.blessed) {</span>
  5268. <span id="line5264">5264. d.otmp->blessed = (Luck >= 0 || wizard);</span>
  5269. <span id="line5265">5265. d.otmp->cursed = (Luck < 0 && !wizard);</span>
  5270. <span id="line5266">5266. } else if (d.spesgn < 0) {</span>
  5271. <span id="line5267">5267. curse(d.otmp);</span>
  5272. <span id="line5268">5268. }</span>
  5273. <span id="line5269">5269. </span>
  5274. <span id="line5270">5270. /* set eroded and erodeproof */</span>
  5275. <span id="line5271">5271. if (erosion_matters(d.otmp)) {</span>
  5276. <span id="line5272">5272. /* wished-for item shouldn't be eroded unless specified */</span>
  5277. <span id="line5273">5273. d.otmp->oeroded = d.otmp->oeroded2 = 0;</span>
  5278. <span id="line5274">5274. if (d.eroded && (is_flammable(d.otmp) || is_rustprone(d.otmp)</span>
  5279. <span id="line5275">5275. || is_crackable(d.otmp)))</span>
  5280. <span id="line5276">5276. d.otmp->oeroded = d.eroded;</span>
  5281. <span id="line5277">5277. if (d.eroded2 && (is_corrodeable(d.otmp) || is_rottable(d.otmp)))</span>
  5282. <span id="line5278">5278. d.otmp->oeroded2 = d.eroded2;</span>
  5283. <span id="line5279">5279. /*</span>
  5284. <span id="line5280">5280. * 3.6.1: earlier versions included `&& !eroded && !eroded2' here,</span>
  5285. <span id="line5281">5281. * but damageproof combined with damaged is feasible (eroded</span>
  5286. <span id="line5282">5282. * armor modified by confused reading of cursed destroy armor)</span>
  5287. <span id="line5283">5283. * so don't prevent player from wishing for such a combination.</span>
  5288. <span id="line5284">5284. */</span>
  5289. <span id="line5285">5285. if (d.erodeproof</span>
  5290. <span id="line5286">5286. && (is_damageable(d.otmp) || d.otmp->otyp == CRYSKNIFE))</span>
  5291. <span id="line5287">5287. d.otmp->oerodeproof = (Luck >= 0 || wizard);</span>
  5292. <span id="line5288">5288. }</span>
  5293. <span id="line5289">5289. </span>
  5294. <span id="line5290">5290. /* set otmp->recharged */</span>
  5295. <span id="line5291">5291. if (d.oclass == WAND_CLASS) {</span>
  5296. <span id="line5292">5292. /* prevent wishing abuse */</span>
  5297. <span id="line5293">5293. if (d.otmp->otyp == WAN_WISHING && !wizard)</span>
  5298. <span id="line5294">5294. d.rechrg = 1;</span>
  5299. <span id="line5295">5295. d.otmp->recharged = (unsigned) d.rechrg;</span>
  5300. <span id="line5296">5296. }</span>
  5301. <span id="line5297">5297. </span>
  5302. <span id="line5298">5298. /* set poisoned */</span>
  5303. <span id="line5299">5299. if (d.ispoisoned) {</span>
  5304. <span id="line5300">5300. if (is_poisonable(d.otmp))</span>
  5305. <span id="line5301">5301. d.otmp->opoisoned = (Luck >= 0);</span>
  5306. <span id="line5302">5302. else if (d.oclass == FOOD_CLASS)</span>
  5307. <span id="line5303">5303. /* try to taint by making it as old as possible */</span>
  5308. <span id="line5304">5304. d.otmp->age = 1L;</span>
  5309. <span id="line5305">5305. }</span>
  5310. <span id="line5306">5306. /* and [un]trapped */</span>
  5311. <span id="line5307">5307. if (d.trapped) {</span>
  5312. <span id="line5308">5308. if (Is_box(d.otmp) || d.typ == TIN)</span>
  5313. <span id="line5309">5309. d.otmp->otrapped = (d.trapped == 1);</span>
  5314. <span id="line5310">5310. }</span>
  5315. <span id="line5311">5311. /* empty for containers rather than for tins */</span>
  5316. <span id="line5312">5312. if (d.contents == TIN_EMPTY) {</span>
  5317. <span id="line5313">5313. if (d.otmp->otyp == BAG_OF_TRICKS || d.otmp->otyp == HORN_OF_PLENTY) {</span>
  5318. <span id="line5314">5314. if (d.otmp->spe > 0)</span>
  5319. <span id="line5315">5315. d.otmp->spe = 0;</span>
  5320. <span id="line5316">5316. } else if (Has_contents(d.otmp)) {</span>
  5321. <span id="line5317">5317. /* this assumes that artifacts can't be randomly generated</span>
  5322. <span id="line5318">5318. inside containers */</span>
  5323. <span id="line5319">5319. delete_contents(d.otmp);</span>
  5324. <span id="line5320">5320. d.otmp->owt = weight(d.otmp);</span>
  5325. <span id="line5321">5321. }</span>
  5326. <span id="line5322">5322. }</span>
  5327. <span id="line5323">5323. /* set locked/unlocked/broken */</span>
  5328. <span id="line5324">5324. if (Is_box(d.otmp)) {</span>
  5329. <span id="line5325">5325. if (d.locked) {</span>
  5330. <span id="line5326">5326. d.otmp->olocked = 1, d.otmp->obroken = 0;</span>
  5331. <span id="line5327">5327. } else if (d.unlocked) {</span>
  5332. <span id="line5328">5328. d.otmp->olocked = 0, d.otmp->obroken = 0;</span>
  5333. <span id="line5329">5329. } else if (d.broken) {</span>
  5334. <span id="line5330">5330. d.otmp->olocked = 0, d.otmp->obroken = 1;</span>
  5335. <span id="line5331">5331. }</span>
  5336. <span id="line5332">5332. if (d.otmp->obroken)</span>
  5337. <span id="line5333">5333. d.otmp->otrapped = 0;</span>
  5338. <span id="line5334">5334. }</span>
  5339. <span id="line5335">5335. </span>
  5340. <span id="line5336">5336. if (d.isgreased)</span>
  5341. <span id="line5337">5337. d.otmp->greased = 1;</span>
  5342. <span id="line5338">5338. </span>
  5343. <span id="line5339">5339. if (d.isdiluted && d.otmp->oclass == POTION_CLASS)</span>
  5344. <span id="line5340">5340. d.otmp->odiluted = (d.otmp->otyp != POT_WATER);</span>
  5345. <span id="line5341">5341. </span>
  5346. <span id="line5342">5342. /* set tin variety */</span>
  5347. <span id="line5343">5343. if (d.otmp->otyp == TIN && d.tvariety >= 0 && (rn2(4) || wizard))</span>
  5348. <span id="line5344">5344. set_tin_variety(d.otmp, d.tvariety);</span>
  5349. <span id="line5345">5345. </span>
  5350. <span id="line5346">5346. if (d.name) {</span>
  5351. <span id="line5347">5347. const char *aname, *novelname;</span>
  5352. <span id="line5348">5348. short objtyp;</span>
  5353. <span id="line5349">5349. </span>
  5354. <span id="line5350">5350. /* an artifact name might need capitalization fixing */</span>
  5355. <span id="line5351">5351. aname = artifact_name(d.name, &objtyp, TRUE);</span>
  5356. <span id="line5352">5352. if (aname && objtyp == d.otmp->otyp)</span>
  5357. <span id="line5353">5353. d.name = aname;</span>
  5358. <span id="line5354">5354. </span>
  5359. <span id="line5355">5355. /* 3.6 tribute - fix up novel */</span>
  5360. <span id="line5356">5356. if (d.otmp->otyp == SPE_NOVEL</span>
  5361. <span id="line5357">5357. && (novelname = lookup_novel(d.name, &d.otmp->novelidx)) != 0)</span>
  5362. <span id="line5358">5358. d.name = novelname;</span>
  5363. <span id="line5359">5359. </span>
  5364. <span id="line5360">5360. d.otmp = oname(d.otmp, d.name, ONAME_WISH);</span>
  5365. <span id="line5361">5361. /* name==aname => wished for artifact (otmp->oartifact => got it) */</span>
  5366. <span id="line5362">5362. if (d.otmp->oartifact || d.name == aname) {</span>
  5367. <span id="line5363">5363. d.otmp->quan = 1L;</span>
  5368. <span id="line5364">5364. u.uconduct.wisharti++; /* KMH, conduct */</span>
  5369. <span id="line5365">5365. }</span>
  5370. <span id="line5366">5366. }</span>
  5371. <span id="line5367">5367. </span>
  5372. <span id="line5368">5368. if (permapoisoned(d.otmp))</span>
  5373. <span id="line5369">5369. d.otmp->opoisoned = 1;</span>
  5374. <span id="line5370">5370. </span>
  5375. <span id="line5371">5371. /* more wishing abuse: don't allow wishing for certain artifacts */</span>
  5376. <span id="line5372">5372. /* and make them pay; charge them for the wish anyway! */</span>
  5377. <span id="line5373">5373. if ((is_quest_artifact(d.otmp)</span>
  5378. <span id="line5374">5374. || (d.otmp->oartifact && rn2(nartifact_exist()) > 1)) && !wizard) {</span>
  5379. <span id="line5375">5375. artifact_exists(d.otmp, safe_oname(d.otmp), FALSE, ONAME_NO_FLAGS);</span>
  5380. <span id="line5376">5376. obfree(d.otmp, (struct obj *) 0);</span>
  5381. <span id="line5377">5377. d.otmp = &hands_obj;</span>
  5382. <span id="line5378">5378. pline("For a moment, you feel %s in your %s, but it disappears!",</span>
  5383. <span id="line5379">5379. something, makeplural(body_part(HAND)));</span>
  5384. <span id="line5380">5380. return d.otmp;</span>
  5385. <span id="line5381">5381. }</span>
  5386. <span id="line5382">5382. </span>
  5387. <span id="line5383">5383. if (d.halfeaten && d.otmp->oclass == FOOD_CLASS) {</span>
  5388. <span id="line5384">5384. unsigned nut = obj_nutrition(d.otmp);</span>
  5389. <span id="line5385">5385. </span>
  5390. <span id="line5386">5386. /* do this adjustment before setting up object's weight; skip</span>
  5391. <span id="line5387">5387. "partly eaten" for food with 0 nutrition (wraith corpse) or for</span>
  5392. <span id="line5388">5388. anything that couldn't take more than one bite (1 nutrition;</span>
  5393. <span id="line5389">5389. ought to check for one-bite instead but that's complicated) */</span>
  5394. <span id="line5390">5390. if (nut > 1) {</span>
  5395. <span id="line5391">5391. d.otmp->oeaten = nut;</span>
  5396. <span id="line5392">5392. consume_oeaten(d.otmp, 1);</span>
  5397. <span id="line5393">5393. }</span>
  5398. <span id="line5394">5394. }</span>
  5399. <span id="line5395">5395. d.otmp->owt = weight(d.otmp);</span>
  5400. <span id="line5396">5396. if (d.very && d.otmp->otyp == HEAVY_IRON_BALL)</span>
  5401. <span id="line5397">5397. d.otmp->owt += WT_IRON_BALL_INCR;</span>
  5402. <span id="line5398">5398. </span>
  5403. <span id="line5399">5399. return d.otmp;</span>
  5404. <span id="line5400">5400. }</span>
  5405. <span id="line5401">5401. </span>
  5406. <span id="line5402">5402. int</span>
  5407. <span id="line5403">5403. rnd_class(int first, int last)</span>
  5408. <span id="line5404">5404. {</span>
  5409. <span id="line5405">5405. int i, x, sum = 0;</span>
  5410. <span id="line5406">5406. </span>
  5411. <span id="line5407">5407. if (last > first) {</span>
  5412. <span id="line5408">5408. for (i = first; i <= last; i++)</span>
  5413. <span id="line5409">5409. sum += objects[i].oc_prob;</span>
  5414. <span id="line5410">5410. if (!sum) /* all zero, so equal probability */</span>
  5415. <span id="line5411">5411. return rn1(last - first + 1, first);</span>
  5416. <span id="line5412">5412. </span>
  5417. <span id="line5413">5413. x = rnd(sum);</span>
  5418. <span id="line5414">5414. for (i = first; i <= last; i++)</span>
  5419. <span id="line5415">5415. if ((x -= objects[i].oc_prob) <= 0)</span>
  5420. <span id="line5416">5416. return i;</span>
  5421. <span id="line5417">5417. }</span>
  5422. <span id="line5418">5418. return (first == last) ? first : STRANGE_OBJECT;</span>
  5423. <span id="line5419">5419. }</span>
  5424. <span id="line5420">5420. </span>
  5425. <span id="line5421">5421. const char *</span>
  5426. <span id="line5422">5422. Japanese_item_name(int i, const char *ordinaryname)</span>
  5427. <span id="line5423">5423. {</span>
  5428. <span id="line5424">5424. const struct Jitem *j = Japanese_items;</span>
  5429. <span id="line5425">5425. </span>
  5430. <span id="line5426">5426. while (j->item) {</span>
  5431. <span id="line5427">5427. if (i == j->item)</span>
  5432. <span id="line5428">5428. return j->name;</span>
  5433. <span id="line5429">5429. j++;</span>
  5434. <span id="line5430">5430. }</span>
  5435. <span id="line5431">5431. return ordinaryname;</span>
  5436. <span id="line5432">5432. }</span>
  5437. <span id="line5433">5433. </span>
  5438. <span id="line5434">5434. const char *</span>
  5439. <span id="line5435">5435. armor_simple_name(struct obj *armor)</span>
  5440. <span id="line5436">5436. {</span>
  5441. <span id="line5437">5437. const char *result = 0;</span>
  5442. <span id="line5438">5438. unsigned armcat = objects[armor->otyp].oc_armcat;</span>
  5443. <span id="line5439">5439. </span>
  5444. <span id="line5440">5440. switch (armcat) {</span>
  5445. <span id="line5441">5441. case ARM_SUIT:</span>
  5446. <span id="line5442">5442. result = suit_simple_name(armor);</span>
  5447. <span id="line5443">5443. break;</span>
  5448. <span id="line5444">5444. case ARM_CLOAK:</span>
  5449. <span id="line5445">5445. result = cloak_simple_name(armor);</span>
  5450. <span id="line5446">5446. break;</span>
  5451. <span id="line5447">5447. case ARM_HELM:</span>
  5452. <span id="line5448">5448. result = helm_simple_name(armor);</span>
  5453. <span id="line5449">5449. break;</span>
  5454. <span id="line5450">5450. case ARM_GLOVES:</span>
  5455. <span id="line5451">5451. result = gloves_simple_name(armor);</span>
  5456. <span id="line5452">5452. break;</span>
  5457. <span id="line5453">5453. case ARM_BOOTS:</span>
  5458. <span id="line5454">5454. result = boots_simple_name(armor);</span>
  5459. <span id="line5455">5455. break;</span>
  5460. <span id="line5456">5456. case ARM_SHIELD:</span>
  5461. <span id="line5457">5457. result = shield_simple_name(armor);</span>
  5462. <span id="line5458">5458. break;</span>
  5463. <span id="line5459">5459. case ARM_SHIRT:</span>
  5464. <span id="line5460">5460. result = shirt_simple_name(armor);</span>
  5465. <span id="line5461">5461. break;</span>
  5466. <span id="line5462">5462. default:</span>
  5467. <span id="line5463">5463. result = simpleonames(armor);</span>
  5468. <span id="line5464">5464. impossible("unknown armor category (%s => %u)", result, armcat);</span>
  5469. <span id="line5465">5465. break;</span>
  5470. <span id="line5466">5466. }</span>
  5471. <span id="line5467">5467. return result;</span>
  5472. <span id="line5468">5468. }</span>
  5473. <span id="line5469">5469. </span>
  5474. <span id="line5470">5470. const char *</span>
  5475. <span id="line5471">5471. suit_simple_name(struct obj *suit)</span>
  5476. <span id="line5472">5472. {</span>
  5477. <span id="line5473">5473. const char *suitnm, *esuitp;</span>
  5478. <span id="line5474">5474. </span>
  5479. <span id="line5475">5475. if (suit) {</span>
  5480. <span id="line5476">5476. if (Is_dragon_mail(suit))</span>
  5481. <span id="line5477">5477. return "dragon mail"; /* <color> dragon scale mail */</span>
  5482. <span id="line5478">5478. else if (Is_dragon_scales(suit))</span>
  5483. <span id="line5479">5479. return "dragon scales";</span>
  5484. <span id="line5480">5480. suitnm = OBJ_NAME(objects[suit->otyp]);</span>
  5485. <span id="line5481">5481. esuitp = eos((char *) suitnm);</span>
  5486. <span id="line5482">5482. if (strlen(suitnm) > 5 && !strcmp(esuitp - 5, " mail"))</span>
  5487. <span id="line5483">5483. return "mail"; /* most suits fall into this category */</span>
  5488. <span id="line5484">5484. else if (strlen(suitnm) > 7 && !strcmp(esuitp - 7, " jacket"))</span>
  5489. <span id="line5485">5485. return "jacket"; /* leather jacket */</span>
  5490. <span id="line5486">5486. }</span>
  5491. <span id="line5487">5487. /* "suit" is lame but "armor" is ambiguous and "body armor" is absurd */</span>
  5492. <span id="line5488">5488. return "suit";</span>
  5493. <span id="line5489">5489. }</span>
  5494. <span id="line5490">5490. </span>
  5495. <span id="line5491">5491. const char *</span>
  5496. <span id="line5492">5492. cloak_simple_name(struct obj *cloak)</span>
  5497. <span id="line5493">5493. {</span>
  5498. <span id="line5494">5494. if (cloak) {</span>
  5499. <span id="line5495">5495. switch (cloak->otyp) {</span>
  5500. <span id="line5496">5496. case ROBE:</span>
  5501. <span id="line5497">5497. return "robe";</span>
  5502. <span id="line5498">5498. case MUMMY_WRAPPING:</span>
  5503. <span id="line5499">5499. return "wrapping";</span>
  5504. <span id="line5500">5500. case ALCHEMY_SMOCK:</span>
  5505. <span id="line5501">5501. return (objects[cloak->otyp].oc_name_known && cloak->dknown)</span>
  5506. <span id="line5502">5502. ? "smock"</span>
  5507. <span id="line5503">5503. : "apron";</span>
  5508. <span id="line5504">5504. default:</span>
  5509. <span id="line5505">5505. break;</span>
  5510. <span id="line5506">5506. }</span>
  5511. <span id="line5507">5507. }</span>
  5512. <span id="line5508">5508. return "cloak";</span>
  5513. <span id="line5509">5509. }</span>
  5514. <span id="line5510">5510. </span>
  5515. <span id="line5511">5511. /* helm vs hat for messages */</span>
  5516. <span id="line5512">5512. const char *</span>
  5517. <span id="line5513">5513. helm_simple_name(struct obj *helmet)</span>
  5518. <span id="line5514">5514. {</span>
  5519. <span id="line5515">5515. /*</span>
  5520. <span id="line5516">5516. * There is some wiggle room here; the result has been chosen</span>
  5521. <span id="line5517">5517. * for consistency with the "protected by hard helmet" messages</span>
  5522. <span id="line5518">5518. * given for various bonks on the head: headgear that provides</span>
  5523. <span id="line5519">5519. * such protection is a "helm", that which doesn't is a "hat".</span>
  5524. <span id="line5520">5520. *</span>
  5525. <span id="line5521">5521. * elven leather helm / leather hat -> hat</span>
  5526. <span id="line5522">5522. * dwarvish iron helm / hard hat -> helm</span>
  5527. <span id="line5523">5523. * The rest are completely straightforward:</span>
  5528. <span id="line5524">5524. * fedora, cornuthaum, dunce cap -> hat</span>
  5529. <span id="line5525">5525. * all other types of helmets -> helm</span>
  5530. <span id="line5526">5526. */</span>
  5531. <span id="line5527">5527. return !hard_helmet(helmet) ? "hat" : "helm";</span>
  5532. <span id="line5528">5528. }</span>
  5533. <span id="line5529">5529. </span>
  5534. <span id="line5530">5530. /* gloves vs gauntlets; depends upon discovery state */</span>
  5535. <span id="line5531">5531. const char *</span>
  5536. <span id="line5532">5532. gloves_simple_name(struct obj *gloves)</span>
  5537. <span id="line5533">5533. {</span>
  5538. <span id="line5534">5534. static const char gauntlets[] = "gauntlets";</span>
  5539. <span id="line5535">5535. </span>
  5540. <span id="line5536">5536. if (gloves && gloves->dknown) {</span>
  5541. <span id="line5537">5537. int otyp = gloves->otyp;</span>
  5542. <span id="line5538">5538. struct objclass *ocl = &objects[otyp];</span>
  5543. <span id="line5539">5539. const char *actualn = OBJ_NAME(*ocl),</span>
  5544. <span id="line5540">5540. *descrpn = OBJ_DESCR(*ocl);</span>
  5545. <span id="line5541">5541. </span>
  5546. <span id="line5542">5542. if (strstri(objects[otyp].oc_name_known ? actualn : descrpn,</span>
  5547. <span id="line5543">5543. gauntlets))</span>
  5548. <span id="line5544">5544. return gauntlets;</span>
  5549. <span id="line5545">5545. }</span>
  5550. <span id="line5546">5546. return "gloves";</span>
  5551. <span id="line5547">5547. }</span>
  5552. <span id="line5548">5548. </span>
  5553. <span id="line5549">5549. /* boots vs shoes; depends upon discovery state */</span>
  5554. <span id="line5550">5550. const char *</span>
  5555. <span id="line5551">5551. boots_simple_name(struct obj *boots)</span>
  5556. <span id="line5552">5552. {</span>
  5557. <span id="line5553">5553. static const char shoes[] = "shoes";</span>
  5558. <span id="line5554">5554. </span>
  5559. <span id="line5555">5555. if (boots && boots->dknown) {</span>
  5560. <span id="line5556">5556. int otyp = boots->otyp;</span>
  5561. <span id="line5557">5557. struct objclass *ocl = &objects[otyp];</span>
  5562. <span id="line5558">5558. const char *actualn = OBJ_NAME(*ocl),</span>
  5563. <span id="line5559">5559. *descrpn = OBJ_DESCR(*ocl);</span>
  5564. <span id="line5560">5560. </span>
  5565. <span id="line5561">5561. if (strstri(descrpn, shoes)</span>
  5566. <span id="line5562">5562. || (objects[otyp].oc_name_known && strstri(actualn, shoes)))</span>
  5567. <span id="line5563">5563. return shoes;</span>
  5568. <span id="line5564">5564. }</span>
  5569. <span id="line5565">5565. return "boots";</span>
  5570. <span id="line5566">5566. }</span>
  5571. <span id="line5567">5567. </span>
  5572. <span id="line5568">5568. /* simplified shield for messages */</span>
  5573. <span id="line5569">5569. const char *</span>
  5574. <span id="line5570">5570. shield_simple_name(struct obj *shield)</span>
  5575. <span id="line5571">5571. {</span>
  5576. <span id="line5572">5572. if (shield) {</span>
  5577. <span id="line5573">5573. /* xname() describes unknown (unseen) reflection as smooth */</span>
  5578. <span id="line5574">5574. if (shield->otyp == SHIELD_OF_REFLECTION)</span>
  5579. <span id="line5575">5575. return shield->dknown ? "silver shield" : "smooth shield";</span>
  5580. <span id="line5576">5576. /*</span>
  5581. <span id="line5577">5577. * We might distinguish between wooden vs metallic or</span>
  5582. <span id="line5578">5578. * light vs heavy to give small benefit to spell casters.</span>
  5583. <span id="line5579">5579. * Fighter types probably care more about the former for</span>
  5584. <span id="line5580">5580. * vulnerability to fire or rust.</span>
  5585. <span id="line5581">5581. *</span>
  5586. <span id="line5582">5582. * We could do that both ways: light wooden shield, light</span>
  5587. <span id="line5583">5583. * metallic shield (there aren't any), heavy wooden shield,</span>
  5588. <span id="line5584">5584. * and heavy metallic shield but that's getting away from</span>
  5589. <span id="line5585">5585. * "simple name" which is intended to be shorter as well</span>
  5590. <span id="line5586">5586. * as less detailed than xname().</span>
  5591. <span id="line5587">5587. */</span>
  5592. <span id="line5588">5588. #if 0</span>
  5593. <span id="line5589">5589. /* spellcasting uses a division like this */</span>
  5594. <span id="line5590">5590. return (weight(shield) > (int) objects[SMALL_SHIELD].oc_weight)</span>
  5595. <span id="line5591">5591. ? "heavy shield"</span>
  5596. <span id="line5592">5592. : "light shield";</span>
  5597. <span id="line5593">5593. #endif</span>
  5598. <span id="line5594">5594. }</span>
  5599. <span id="line5595">5595. return "shield";</span>
  5600. <span id="line5596">5596. }</span>
  5601. <span id="line5597">5597. </span>
  5602. <span id="line5598">5598. /* for completeness */</span>
  5603. <span id="line5599">5599. const char *</span>
  5604. <span id="line5600">5600. shirt_simple_name(struct obj *shirt UNUSED)</span>
  5605. <span id="line5601">5601. {</span>
  5606. <span id="line5602">5602. return "shirt";</span>
  5607. <span id="line5603">5603. }</span>
  5608. <span id="line5604">5604. </span>
  5609. <span id="line5605">5605. const char *</span>
  5610. <span id="line5606">5606. mimic_obj_name(struct monst *mtmp)</span>
  5611. <span id="line5607">5607. {</span>
  5612. <span id="line5608">5608. if (M_AP_TYPE(mtmp) == M_AP_OBJECT) {</span>
  5613. <span id="line5609">5609. if (mtmp->mappearance == GOLD_PIECE)</span>
  5614. <span id="line5610">5610. return "gold";</span>
  5615. <span id="line5611">5611. if (mtmp->mappearance != STRANGE_OBJECT)</span>
  5616. <span id="line5612">5612. return simple_typename(mtmp->mappearance);</span>
  5617. <span id="line5613">5613. }</span>
  5618. <span id="line5614">5614. return "whatcha-may-callit";</span>
  5619. <span id="line5615">5615. }</span>
  5620. <span id="line5616">5616. </span>
  5621. <span id="line5617">5617. /*</span>
  5622. <span id="line5618">5618. * Construct a query prompt string, based around an object name, which is</span>
  5623. <span id="line5619">5619. * guaranteed to fit within [QBUFSZ]. Takes an optional prefix, three</span>
  5624. <span id="line5620">5620. * choices for filling in the middle (two object formatting functions and a</span>
  5625. <span id="line5621">5621. * last resort literal which should be very short), and an optional suffix.</span>
  5626. <span id="line5622">5622. */</span>
  5627. <span id="line5623">5623. char *</span>
  5628. <span id="line5624">5624. safe_qbuf(</span>
  5629. <span id="line5625">5625. char *qbuf, /* output buffer */</span>
  5630. <span id="line5626">5626. const char *qprefix,</span>
  5631. <span id="line5627">5627. const char *qsuffix,</span>
  5632. <span id="line5628">5628. struct obj *obj,</span>
  5633. <span id="line5629">5629. char *(*func)(OBJ_P),</span>
  5634. <span id="line5630">5630. char *(*altfunc)(OBJ_P),</span>
  5635. <span id="line5631">5631. const char *lastR)</span>
  5636. <span id="line5632">5632. {</span>
  5637. <span id="line5633">5633. char *bufp, *endp;</span>
  5638. <span id="line5634">5634. /* convert size_t (or int for ancient systems) to ordinary unsigned */</span>
  5639. <span id="line5635">5635. unsigned len, lenlimit,</span>
  5640. <span id="line5636">5636. len_qpfx = (unsigned) (qprefix ? strlen(qprefix) : 0),</span>
  5641. <span id="line5637">5637. len_qsfx = (unsigned) (qsuffix ? strlen(qsuffix) : 0),</span>
  5642. <span id="line5638">5638. len_lastR = (unsigned) strlen(lastR);</span>
  5643. <span id="line5639">5639. </span>
  5644. <span id="line5640">5640. lenlimit = QBUFSZ - 1;</span>
  5645. <span id="line5641">5641. endp = qbuf + lenlimit;</span>
  5646. <span id="line5642">5642. assert(endp != NULL); /* workaround for static analyzer issue */</span>
  5647. <span id="line5643">5643. /* sanity check, aimed mainly at paniclog (it's conceivable for</span>
  5648. <span id="line5644">5644. the result of short_oname() to be shorter than the length of</span>
  5649. <span id="line5645">5645. the last resort string, but we ignore that possibility here) */</span>
  5650. <span id="line5646">5646. if (len_qpfx > lenlimit)</span>
  5651. <span id="line5647">5647. impossible("safe_qbuf: prefix too long (%u characters).", len_qpfx);</span>
  5652. <span id="line5648">5648. else if (len_qpfx + len_qsfx > lenlimit)</span>
  5653. <span id="line5649">5649. impossible("safe_qbuf: suffix too long (%u + %u characters).",</span>
  5654. <span id="line5650">5650. len_qpfx, len_qsfx);</span>
  5655. <span id="line5651">5651. else if (len_qpfx + len_lastR + len_qsfx > lenlimit)</span>
  5656. <span id="line5652">5652. impossible("safe_qbuf: filler too long (%u + %u + %u characters).",</span>
  5657. <span id="line5653">5653. len_qpfx, len_lastR, len_qsfx);</span>
  5658. <span id="line5654">5654. </span>
  5659. <span id="line5655">5655. /* the output buffer might be the same as the prefix if caller</span>
  5660. <span id="line5656">5656. has already partially filled it */</span>
  5661. <span id="line5657">5657. if (qbuf == qprefix) {</span>
  5662. <span id="line5658">5658. /* prefix is already in the buffer */</span>
  5663. <span id="line5659">5659. *endp = '\0';</span>
  5664. <span id="line5660">5660. } else if (qprefix) {</span>
  5665. <span id="line5661">5661. /* put prefix into the buffer */</span>
  5666. <span id="line5662">5662. (void) strncpy(qbuf, qprefix, lenlimit);</span>
  5667. <span id="line5663">5663. *endp = '\0';</span>
  5668. <span id="line5664">5664. } else {</span>
  5669. <span id="line5665">5665. /* no prefix; output buffer starts out empty */</span>
  5670. <span id="line5666">5666. qbuf[0] = '\0';</span>
  5671. <span id="line5667">5667. }</span>
  5672. <span id="line5668">5668. len = (unsigned) strlen(qbuf);</span>
  5673. <span id="line5669">5669. </span>
  5674. <span id="line5670">5670. if (len + len_lastR + len_qsfx > lenlimit) {</span>
  5675. <span id="line5671">5671. /* too long; skip formatting, last resort output is truncated */</span>
  5676. <span id="line5672">5672. if (len < lenlimit) {</span>
  5677. <span id="line5673">5673. (void) strncpy(&qbuf[len], lastR, lenlimit - len);</span>
  5678. <span id="line5674">5674. *endp = '\0';</span>
  5679. <span id="line5675">5675. len = (unsigned) strlen(qbuf);</span>
  5680. <span id="line5676">5676. if (qsuffix && len < lenlimit) {</span>
  5681. <span id="line5677">5677. (void) strncpy(&qbuf[len], qsuffix, lenlimit - len);</span>
  5682. <span id="line5678">5678. *endp = '\0';</span>
  5683. <span id="line5679">5679. /* len = (unsigned) strlen(qbuf); */</span>
  5684. <span id="line5680">5680. }</span>
  5685. <span id="line5681">5681. }</span>
  5686. <span id="line5682">5682. } else {</span>
  5687. <span id="line5683">5683. /* suffix and last resort are guaranteed to fit */</span>
  5688. <span id="line5684">5684. len += len_qsfx; /* include the pending suffix */</span>
  5689. <span id="line5685">5685. /* format the object */</span>
  5690. <span id="line5686">5686. bufp = short_oname(obj, func, altfunc, lenlimit - len);</span>
  5691. <span id="line5687">5687. if (len + strlen(bufp) <= lenlimit)</span>
  5692. <span id="line5688">5688. Strcat(qbuf, bufp); /* formatted name fits */</span>
  5693. <span id="line5689">5689. else</span>
  5694. <span id="line5690">5690. Strcat(qbuf, lastR); /* use last resort */</span>
  5695. <span id="line5691">5691. releaseobuf(bufp);</span>
  5696. <span id="line5692">5692. </span>
  5697. <span id="line5693">5693. if (qsuffix)</span>
  5698. <span id="line5694">5694. Strcat(qbuf, qsuffix);</span>
  5699. <span id="line5695">5695. }</span>
  5700. <span id="line5696">5696. /* assert( strlen(qbuf) < QBUFSZ ); */</span>
  5701. <span id="line5697">5697. return qbuf;</span>
  5702. <span id="line5698">5698. }</span>
  5703. <span id="line5699">5699. </span>
  5704. <span id="line5700">5700. /*objnam.c*/</span>
  5705.  
  5706. [[Category:NetHack 5.0.0 source code|src/nhlsel.c]]
Add Comment
Please, Sign In to add comment