?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Drop main() prototype. Syncs with NetBSD-8
[minix.git] / games / rogue / inventory.c
blob934e8aa3f5fd4fa011af791686121336d4c744fb
1 /* $NetBSD: inventory.c,v 1.15 2011/08/26 06:18:17 dholland Exp $ */
2
3 /*
4 * Copyright (c) 1988, 1993
5 * The Regents of the University of California. All rights reserved.
6 *
7 * This code is derived from software contributed to Berkeley by
8 * Timothy C. Stoehr.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. Neither the name of the University nor the names of its contributors
19 * may be used to endorse or promote products derived from this software
20 * without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 */
34
35 #include <sys/cdefs.h>
36 #ifndef lint
37 #if 0
38 static char sccsid[] = "@(#)inventory.c 8.1 (Berkeley) 5/31/93";
39 #else
40 __RCSID("$NetBSD: inventory.c,v 1.15 2011/08/26 06:18:17 dholland Exp $");
41 #endif
42 #endif /* not lint */
43
44 /*
45 * inventory.c
46 *
47 * This source herein may be modified and/or distributed by anybody who
48 * so desires, with the following restrictions:
49 * 1.) No portion of this notice shall be removed.
50 * 2.) Credit shall not be taken for the creation of this source.
51 * 3.) This code is not to be traded, sold, or used for personal
52 * gain or profit.
53 *
54 */
55
56 #include <stdarg.h>
57 #include "rogue.h"
58
59 boolean is_wood[WANDS];
60 const char *press_space = " --press space to continue--";
61
62 static const char *const wand_materials[WAND_MATERIALS] = {
63 "steel ",
64 "bronze ",
65 "gold ",
66 "silver ",
67 "copper ",
68 "nickel ",
69 "cobalt ",
70 "tin ",
71 "iron ",
72 "magnesium ",
73 "chrome ",
74 "carbon ",
75 "platinum ",
76 "silicon ",
77 "titanium ",
78
79 "teak ",
80 "oak ",
81 "cherry ",
82 "birch ",
83 "pine ",
84 "cedar ",
85 "redwood ",
86 "balsa ",
87 "ivory ",
88 "walnut ",
89 "maple ",
90 "mahogany ",
91 "elm ",
92 "palm ",
93 "wooden "
94 };
95
96 static const char *const gems[GEMS] = {
97 "diamond ",
98 "stibotantalite ",
99 "lapi-lazuli ",
100 "ruby ",
101 "emerald ",
102 "sapphire ",
103 "amethyst ",
104 "quartz ",
105 "tiger-eye ",
106 "opal ",
107 "agate ",
108 "turquoise ",
109 "pearl ",
110 "garnet "
111 };
112
113 static const char *const syllables[MAXSYLLABLES] = {
114 "blech ",
115 "foo ",
116 "barf ",
117 "rech ",
118 "bar ",
119 "blech ",
120 "quo ",
121 "bloto ",
122 "oh ",
123 "caca ",
124 "blorp ",
125 "erp ",
126 "festr ",
127 "rot ",
128 "slie ",
129 "snorf ",
130 "iky ",
131 "yuky ",
132 "ooze ",
133 "ah ",
134 "bahl ",
135 "zep ",
136 "druhl ",
137 "flem ",
138 "behil ",
139 "arek ",
140 "mep ",
141 "zihr ",
142 "grit ",
143 "kona ",
144 "kini ",
145 "ichi ",
146 "tims ",
147 "ogr ",
148 "oo ",
149 "ighr ",
150 "coph ",
151 "swerr ",
152 "mihln ",
153 "poxi "
154 };
155
156 #define COMS 48
157
158 struct id_com_s {
159 short com_char;
160 const char *com_desc;
161 };
162
163 static const struct id_com_s com_id_tab[COMS] = {
164 {'?', "? prints help"},
165 {'r', "r read scroll"},
166 {'/', "/ identify object"},
167 {'e', "e eat food"},
168 {'h', "h left "},
169 {'w', "w wield a weapon"},
170 {'j', "j down"},
171 {'W', "W wear armor"},
172 {'k', "k up"},
173 {'T', "T take armor off"},
174 {'l', "l right"},
175 {'P', "P put on ring"},
176 {'y', "y up & left"},
177 {'R', "R remove ring"},
178 {'u', "u up & right"},
179 {'d', "d drop object"},
180 {'b', "b down & left"},
181 {'c', "c call object"},
182 {'n', "n down & right"},
183 {'\0', "<SHIFT><dir>: run that way"},
184 {')', ") print current weapon"},
185 {'\0', "<CTRL><dir>: run till adjacent"},
186 {']', "] print current armor"},
187 {'f', "f<dir> fight till death or near death"},
188 {'=', "= print current rings"},
189 {'t', "t<dir> throw something"},
190 {'\001', "^A print Hp-raise average"},
191 {'m', "m<dir> move onto without picking up"},
192 {'z', "z<dir> zap a wand in a direction"},
193 {'o', "o examine/set options"},
194 {'^', "^<dir> identify trap type"},
195 {'\022', "^R redraw screen"},
196 {'&', "& save screen into 'rogue.screen'"},
197 {'s', "s search for trap/secret door"},
198 {'\020', "^P repeat last message"},
199 {'>', "> go down a staircase"},
200 {'\033', "^[ cancel command"},
201 {'<', "< go up a staircase"},
202 {'S', "S save game"},
203 {'.', ". rest for a turn"},
204 {'Q', "Q quit"},
205 {',', ", pick something up"},
206 {'!', "! shell escape"},
207 {'i', "i inventory"},
208 {'F', "F<dir> fight till either of you dies"},
209 {'I', "I inventory single item"},
210 {'v', "v print version number"},
211 {'q', "q quaff potion" }
212 };
213
214 static int get_com_id(int *, short);
215 static int pr_com_id(int);
216 static int pr_motion_char(int);
217
218 void
219 inventory(const object *pack, unsigned short mask)
220 {
221 object *obj;
222 short i = 0, j;
223 size_t maxlen = 0, n;
224 short row, col;
225
226 struct {
227 short letter;
228 short sepchar;
229 char desc[DCOLS];
230 char savebuf[DCOLS+8];
231 } descs[MAX_PACK_COUNT+1];
232
233
234 obj = pack->next_object;
235
236 if (!obj) {
237 messagef(0, "your pack is empty");
238 return;
239 }
240 while (obj) {
241 if (obj->what_is & mask) {
242 descs[i].letter = obj->ichar;
243 descs[i].sepchar = ((obj->what_is & ARMOR) && obj->is_protected)
244 ? '}' : ')';
245 get_desc(obj, descs[i].desc, sizeof(descs[i].desc));
246 n = strlen(descs[i].desc) + 4;
247 if (n > maxlen) {
248 maxlen = n;
249 }
250 i++;
251 /*assert(i<=MAX_PACK_COUNT);*/
252 }
253 obj = obj->next_object;
254 }
255 if (maxlen < 27) maxlen = 27;
256 if (maxlen > DCOLS-2) maxlen = DCOLS-2;
257 col = DCOLS - (maxlen + 2);
258
259 for (row = 0; ((row <= i) && (row < DROWS)); row++) {
260 for (j = col; j < DCOLS; j++) {
261 descs[row].savebuf[j-col] = mvinch(row, j);
262 }
263 descs[row].savebuf[j-col] = 0;
264 if (row < i) {
265 mvprintw(row, col, " %c%c %s",
266 descs[row].letter, descs[row].sepchar,
267 descs[row].desc);
268 }
269 else {
270 mvaddstr(row, col, press_space);
271 }
272 clrtoeol();
273 }
274 refresh();
275 wait_for_ack();
276
277 move(0, 0);
278 clrtoeol();
279
280 for (j = 1; ((j <= i) && (j < DROWS)); j++) {
281 mvaddstr(j, col, descs[j].savebuf);
282 }
283 }
284
285 void
286 id_com(void)
287 {
288 int ch = 0;
289 short i, j, k;
290
291 while (ch != CANCEL) {
292 check_message();
293 messagef(0, "Character you want help for (* for all):");
294
295 refresh();
296 ch = getchar();
297
298 switch(ch) {
299 case LIST:
300 {
301 char save[(((COMS / 2) + (COMS % 2)) + 1)][DCOLS];
302 short rows = (((COMS / 2) + (COMS % 2)) + 1);
303 boolean need_two_screens = FALSE;
304
305 if (rows > LINES) {
306 need_two_screens = 1;
307 rows = LINES;
308 }
309 k = 0;
310
311 for (i = 0; i < rows; i++) {
312 for (j = 0; j < DCOLS; j++) {
313 save[i][j] = mvinch(i, j);
314 }
315 }
316 MORE:
317 for (i = 0; i < rows; i++) {
318 move(i, 0);
319 clrtoeol();
320 }
321 for (i = 0; i < (rows-1); i++) {
322 if (i < (LINES-1)) {
323 if (((i + i) < COMS) && ((i+i+k) < COMS)) {
324 mvaddstr(i, 0, com_id_tab[i+i+k].com_desc);
325 }
326 if (((i + i + 1) < COMS) && ((i+i+k+1) < COMS)) {
327 mvaddstr(i, (DCOLS/2),
328 com_id_tab[i+i+k+1].com_desc);
329 }
330 }
331 }
332 mvaddstr(rows - 1, 0, need_two_screens ? more : press_space);
333 refresh();
334 wait_for_ack();
335
336 if (need_two_screens) {
337 k += ((rows-1) * 2);
338 need_two_screens = 0;
339 goto MORE;
340 }
341 for (i = 0; i < rows; i++) {
342 move(i, 0);
343 for (j = 0; j < DCOLS; j++) {
344 addch(save[i][j]);
345 }
346 }
347 }
348 break;
349 default:
350 if (!pr_com_id(ch)) {
351 if (!pr_motion_char(ch)) {
352 check_message();
353 messagef(0, "unknown character");
354 }
355 }
356 ch = CANCEL;
357 break;
358 }
359 }
360 }
361
362 static int
363 pr_com_id(int ch)
364 {
365 int i;
366
367 if (!get_com_id(&i, ch)) {
368 return(0);
369 }
370 check_message();
371 messagef(0, "%s", com_id_tab[i].com_desc);
372 return(1);
373 }
374
375 static int
376 get_com_id(int *indexp, short ch)
377 {
378 short i;
379
380 for (i = 0; i < COMS; i++) {
381 if (com_id_tab[i].com_char == ch) {
382 *indexp = i;
383 return(1);
384 }
385 }
386 return(0);
387 }
388
389 static int
390 pr_motion_char(int ch)
391 {
392 if ( (ch == 'J') ||
393 (ch == 'K') ||
394 (ch == 'L') ||
395 (ch == 'H') ||
396 (ch == 'Y') ||
397 (ch == 'U') ||
398 (ch == 'N') ||
399 (ch == 'B') ||
400 (ch == '\012') ||
401 (ch == '\013') ||
402 (ch == '\010') ||
403 (ch == '\014') ||
404 (ch == '\025') ||
405 (ch == '\031') ||
406 (ch == '\016') ||
407 (ch == '\002')) {
408 const char *until;
409 int n = 0; /* XXX: GCC */
410 if (ch <= '\031') {
411 ch += 96;
412 until = " until adjacent";
413 } else {
414 ch += 32;
415 until = "";
416 }
417 (void)get_com_id(&n, ch);
418 check_message();
419 messagef(0, "run %s%s", com_id_tab[n].com_desc + 8, until);
420 return(1);
421 } else {
422 return(0);
423 }
424 }
425
426 void
427 mix_colors(void)
428 {
429 short i, j, k;
430 char t[MAX_ID_TITLE_LEN];
431
432 for (i = 0; i <= 32; i++) {
433 j = get_rand(0, (POTIONS - 1));
434 k = get_rand(0, (POTIONS - 1));
435 strlcpy(t, id_potions[j].title, sizeof(t));
436 strlcpy(id_potions[j].title, id_potions[k].title,
437 sizeof(id_potions[j].title));
438 strlcpy(id_potions[k].title, t, sizeof(id_potions[k].title));
439 }
440 }
441
442 void
443 make_scroll_titles(void)
444 {
445 short i, j, n;
446 short sylls, s;
447 size_t maxlen = sizeof(id_scrolls[0].title);
448
449 for (i = 0; i < SCROLS; i++) {
450 sylls = get_rand(2, 5);
451 (void)strlcpy(id_scrolls[i].title, "'", maxlen);
452
453 for (j = 0; j < sylls; j++) {
454 s = get_rand(1, (MAXSYLLABLES-1));
455 (void)strlcat(id_scrolls[i].title, syllables[s],
456 maxlen);
457 }
458 /* trim trailing space */
459 n = strlen(id_scrolls[i].title);
460 id_scrolls[i].title[n-1] = 0;
461
462 (void)strlcat(id_scrolls[i].title, "' ", maxlen);
463 }
464 }
465
466 struct sbuf {
467 char *buf;
468 size_t maxlen;
469 };
470
471 static void sbuf_init(struct sbuf *s, char *buf, size_t maxlen);
472 static void sbuf_addstr(struct sbuf *s, const char *str);
473 static void sbuf_addf(struct sbuf *s, const char *fmt, ...) __printflike(2,3);
474 static void desc_count(struct sbuf *s, int n);
475 static void desc_called(struct sbuf *s, const object *);
476
477 static
478 void
479 sbuf_init(struct sbuf *s, char *buf, size_t maxlen)
480 {
481 s->buf = buf;
482 s->maxlen = maxlen;
483 /*assert(maxlen>0);*/
484 s->buf[0] = 0;
485 }
486
487 static
488 void
489 sbuf_addstr(struct sbuf *s, const char *str)
490 {
491 strlcat(s->buf, str, s->maxlen);
492 }
493
494 static
495 void
496 sbuf_addf(struct sbuf *s, const char *fmt, ...)
497 {
498 va_list ap;
499 size_t initlen;
500
501 initlen = strlen(s->buf);
502 va_start(ap, fmt);
503 vsnprintf(s->buf+initlen, s->maxlen-initlen, fmt, ap);
504 va_end(ap);
505 }
506
507 static
508 void
509 desc_count(struct sbuf *s, int n)
510 {
511 if (n == 1) {
512 sbuf_addstr(s, "an ");
513 } else {
514 sbuf_addf(s, "%d ", n);
515 }
516 }
517
518 static
519 void
520 desc_called(struct sbuf *s, const object *obj)
521 {
522 struct id *id_table;
523
524 id_table = get_id_table(obj);
525 sbuf_addstr(s, name_of(obj));
526 sbuf_addstr(s, "called ");
527 sbuf_addstr(s, id_table[obj->which_kind].title);
528 }
529
530 void
531 get_desc(const object *obj, char *desc, size_t desclen)
532 {
533 const char *item_name;
534 struct id *id_table;
535 struct sbuf db;
536 unsigned short objtype_id_status;
537
538 if (obj->what_is == AMULET) {
539 (void)strlcpy(desc, "the amulet of Yendor ", desclen);
540 return;
541 }
542
543 if (obj->what_is == GOLD) {
544 snprintf(desc, desclen, "%d pieces of gold", obj->quantity);
545 return;
546 }
547
548 item_name = name_of(obj);
549 id_table = get_id_table(obj);
550 if (wizard || id_table == NULL) {
551 objtype_id_status = IDENTIFIED;
552 }
553 else {
554 objtype_id_status = id_table[obj->which_kind].id_status;
555 }
556 if (obj->what_is & (WEAPON | ARMOR | WAND | RING)) {
557 if (obj->identified) {
558 objtype_id_status = IDENTIFIED;
559 }
560 }
561
562 sbuf_init(&db, desc, desclen);
563
564 switch (obj->what_is) {
565 case FOOD:
566 if (obj->which_kind == RATION) {
567 if (obj->quantity > 1) {
568 sbuf_addf(&db,
569 "%d rations of %s", obj->quantity,
570 item_name);
571 } else {
572 sbuf_addf(&db, "some %s", item_name);
573 }
574 } else {
575 sbuf_addf(&db, "an %s", item_name);
576 }
577 break;
578 case SCROL:
579 desc_count(&db, obj->quantity);
580 if (objtype_id_status==UNIDENTIFIED) {
581 sbuf_addstr(&db, item_name);
582 sbuf_addstr(&db, "entitled: ");
583 sbuf_addstr(&db, id_table[obj->which_kind].title);
584 } else if (objtype_id_status==CALLED) {
585 desc_called(&db, obj);
586 } else {
587 sbuf_addstr(&db, item_name);
588 sbuf_addstr(&db, id_table[obj->which_kind].real);
589 }
590 break;
591 case POTION:
592 desc_count(&db, obj->quantity);
593 if (objtype_id_status==UNIDENTIFIED) {
594 sbuf_addstr(&db, id_table[obj->which_kind].title);
595 sbuf_addstr(&db, item_name);
596 } else if (objtype_id_status==CALLED) {
597 desc_called(&db, obj);
598 } else {
599 sbuf_addstr(&db, item_name);
600 sbuf_addstr(&db, id_table[obj->which_kind].real);
601 }
602 break;
603 case WAND:
604 desc_count(&db, obj->quantity);
605 if (objtype_id_status==UNIDENTIFIED) {
606 sbuf_addstr(&db, id_table[obj->which_kind].title);
607 sbuf_addstr(&db, item_name);
608 } else if (objtype_id_status==CALLED) {
609 desc_called(&db, obj);
610 } else {
611 sbuf_addstr(&db, item_name);
612 sbuf_addstr(&db, id_table[obj->which_kind].real);
613 if (wizard || obj->identified) {
614 sbuf_addf(&db, "[%d]", obj->class);
615 }
616 }
617 break;
618 case RING:
619 desc_count(&db, obj->quantity);
620 if (objtype_id_status==UNIDENTIFIED) {
621 sbuf_addstr(&db, id_table[obj->which_kind].title);
622 sbuf_addstr(&db, item_name);
623 } else if (objtype_id_status==CALLED) {
624 desc_called(&db, obj);
625 } else {
626 if ((wizard || obj->identified) &&
627 (obj->which_kind == DEXTERITY ||
628 obj->which_kind == ADD_STRENGTH)) {
629 sbuf_addf(&db, "%+d ", obj->class);
630 }
631 sbuf_addstr(&db, item_name);
632 sbuf_addstr(&db, id_table[obj->which_kind].real);
633 }
634 break;
635 case ARMOR:
636 /* no desc_count() */
637 if (objtype_id_status==UNIDENTIFIED) {
638 sbuf_addstr(&db, id_table[obj->which_kind].title);
639 } else {
640 sbuf_addf(&db, "%+d %s[%d] ", obj->d_enchant,
641 id_table[obj->which_kind].title,
642 get_armor_class(obj));
643 }
644 break;
645 case WEAPON:
646 desc_count(&db, obj->quantity);
647 if (objtype_id_status==UNIDENTIFIED) {
648 sbuf_addstr(&db, name_of(obj));
649 } else {
650 sbuf_addf(&db, "%+d,%+d %s",
651 obj->hit_enchant, obj->d_enchant,
652 name_of(obj));
653 }
654 break;
655 }
656
657 if (obj->in_use_flags & BEING_WIELDED) {
658 sbuf_addstr(&db, "in hand");
659 } else if (obj->in_use_flags & BEING_WORN) {
660 sbuf_addstr(&db, "being worn");
661 } else if (obj->in_use_flags & ON_LEFT_HAND) {
662 sbuf_addstr(&db, "on left hand");
663 } else if (obj->in_use_flags & ON_RIGHT_HAND) {
664 sbuf_addstr(&db, "on right hand");
665 }
666
667 if (!strncmp(db.buf, "an ", 3)) {
668 if (!is_vowel(db.buf[3])) {
669 memmove(db.buf+2, db.buf+3, strlen(db.buf+3)+1);
670 db.buf[1] = ' ';
671 }
672 }
673 }
674
675 void
676 get_wand_and_ring_materials(void)
677 {
678 short i, j;
679 boolean used[WAND_MATERIALS];
680
681 for (i = 0; i < WAND_MATERIALS; i++) {
682 used[i] = 0;
683 }
684 for (i = 0; i < WANDS; i++) {
685 do {
686 j = get_rand(0, WAND_MATERIALS-1);
687 } while (used[j]);
688 used[j] = 1;
689 (void)strlcpy(id_wands[i].title, wand_materials[j],
690 sizeof(id_wands[i].title));
691 is_wood[i] = (j > MAX_METAL);
692 }
693 for (i = 0; i < GEMS; i++) {
694 used[i] = 0;
695 }
696 for (i = 0; i < RINGS; i++) {
697 do {
698 j = get_rand(0, GEMS-1);
699 } while (used[j]);
700 used[j] = 1;
701 (void)strlcpy(id_rings[i].title, gems[j],
702 sizeof(id_rings[i].title));
703 }
704 }
705
706 void
707 single_inv(short ichar)
708 {
709 short ch, ch2;
710 char desc[DCOLS];
711 object *obj;
712
713 ch = ichar ? ichar : pack_letter("inventory what?", ALL_OBJECTS);
714
715 if (ch == CANCEL) {
716 return;
717 }
718 if (!(obj = get_letter_object(ch))) {
719 messagef(0, "no such item.");
720 return;
721 }
722 ch2 = ((obj->what_is & ARMOR) && obj->is_protected) ? '}' : ')';
723 get_desc(obj, desc, sizeof(desc));
724 messagef(0, "%c%c %s", ch, ch2, desc);
725 }
726
727 struct id *
728 get_id_table(const object *obj)
729 {
730 switch(obj->what_is) {
731 case SCROL:
732 return(id_scrolls);
733 case POTION:
734 return(id_potions);
735 case WAND:
736 return(id_wands);
737 case RING:
738 return(id_rings);
739 case WEAPON:
740 return(id_weapons);
741 case ARMOR:
742 return(id_armors);
743 }
744 return((struct id *)0);
745 }
746
747 void
748 inv_armor_weapon(boolean is_weapon)
749 {
750 if (is_weapon) {
751 if (rogue.weapon) {
752 single_inv(rogue.weapon->ichar);
753 } else {
754 messagef(0, "not wielding anything");
755 }
756 } else {
757 if (rogue.armor) {
758 single_inv(rogue.armor->ichar);
759 } else {
760 messagef(0, "not wearing anything");
761 }
762 }
763 }
764
765 void
766 id_type(void)
767 {
768 const char *id;
769 int ch;
770
771 messagef(0, "what do you want identified?");
772
773 ch = rgetchar();
774
775 if ((ch >= 'A') && (ch <= 'Z')) {
776 id = m_names[ch-'A'];
777 } else if (ch < 32) {
778 check_message();
779 return;
780 } else {
781 switch(ch) {
782 case '@':
783 id = "you";
784 break;
785 case '%':
786 id = "staircase";
787 break;
788 case '^':
789 id = "trap";
790 break;
791 case '+':
792 id = "door";
793 break;
794 case '-':
795 case '|':
796 id = "wall of a room";
797 break;
798 case '.':
799 id = "floor";
800 break;
801 case '#':
802 id = "passage";
803 break;
804 case ' ':
805 id = "solid rock";
806 break;
807 case '=':
808 id = "ring";
809 break;
810 case '?':
811 id = "scroll";
812 break;
813 case '!':
814 id = "potion";
815 break;
816 case '/':
817 id = "wand or staff";
818 break;
819 case ')':
820 id = "weapon";
821 break;
822 case ']':
823 id = "armor";
824 break;
825 case '*':
826 id = "gold";
827 break;
828 case ':':
829 id = "food";
830 break;
831 case ',':
832 id = "the Amulet of Yendor";
833 break;
834 default:
835 id = "unknown character";
836 break;
837 }
838 }
839 check_message();
840 messagef(0, "'%c': %s", ch, id);
841 }
MINIX 3 (repo.or.cz mirror)