0946a3d95ca9aeac9ec5ee6237cbfb922db22abf
[dragonfly.git] / games / rogue / object.c
1 /*
2  * Copyright (c) 1988, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * Timothy C. Stoehr.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *      This product includes software developed by the University of
19  *      California, Berkeley and its contributors.
20  * 4. Neither the name of the University nor the names of its contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  *
36  * @(#)object.c 8.1 (Berkeley) 5/31/93
37  * $FreeBSD: src/games/rogue/object.c,v 1.5 1999/11/30 03:49:25 billf Exp $
38  * $DragonFly: src/games/rogue/object.c,v 1.4 2006/09/02 19:31:07 pavalos Exp $
39  */
40
41 /*
42  * object.c
43  *
44  * This source herein may be modified and/or distributed by anybody who
45  * so desires, with the following restrictions:
46  *    1.)  No portion of this notice shall be removed.
47  *    2.)  Credit shall not be taken for the creation of this source.
48  *    3.)  This code is not to be traded, sold, or used for personal
49  *         gain or profit.
50  *
51  */
52
53 #include "rogue.h"
54
55 object level_objects;
56 unsigned short dungeon[DROWS][DCOLS];
57 short foods = 0;
58 object *free_list = (object *) 0;
59 char *fruit = (char *) 0;
60
61 fighter rogue = {
62         INIT_AW,        /* armor, weapon */
63         INIT_RINGS,     /* rings */
64         INIT_HP,INIT_HP,/* Hp current,max */
65         INIT_STR,       /* Str current,max */
66         INIT_PACK,      /* pack */
67         INIT_GOLD,      /* gold */
68         INIT_EXP,       /* exp level,points */
69         0, 0,           /* row, col */
70         INIT_CHAR,      /* char */
71         INIT_MOVES      /* moves */
72 };
73
74 struct id id_potions[POTIONS] = {
75 {100, "blue \0                           ", "of increase strength ", 0},
76 {250, "red \0                            ", "of restore strength ", 0},
77 {100, "green \0                          ", "of healing ", 0},
78 {200, "grey \0                           ", "of extra healing ", 0},
79  {10, "brown \0                          ", "of poison ", 0},
80 {300, "clear \0                          ", "of raise level ", 0},
81  {10, "pink \0                           ", "of blindness ", 0},
82  {25, "white \0                          ", "of hallucination ", 0},
83 {100, "purple \0                         ", "of detect monster ", 0},
84 {100, "black \0                          ", "of detect things ", 0},
85  {10, "yellow \0                         ", "of confusion ", 0},
86  {80, "plaid \0                          ", "of levitation ", 0},
87 {150, "burgundy \0                       ", "of haste self ", 0},
88 {145, "beige \0                          ", "of see invisible ", 0}
89 };
90
91 struct id id_scrolls[SCROLS] = {
92 {505, "                                   ", "of protect armor ", 0},
93 {200, "                                   ", "of hold monster ", 0},
94 {235, "                                   ", "of enchant weapon ", 0},
95 {235, "                                   ", "of enchant armor ", 0},
96 {175, "                                   ", "of identify ", 0},
97 {190, "                                   ", "of teleportation ", 0},
98  {25, "                                   ", "of sleep ", 0},
99 {610, "                                   ", "of scare monster ", 0},
100 {210, "                                   ", "of remove curse ", 0},
101  {80, "                                   ", "of create monster ",0},
102  {25, "                                   ", "of aggravate monster ",0},
103 {180, "                                   ", "of magic mapping ", 0},
104  {90, "                                   ", "of confuse monster ", 0}
105 };
106
107 struct id id_weapons[WEAPONS] = {
108         {150, "short bow ", "", 0},
109           {8, "darts ", "", 0},
110          {15, "arrows ", "", 0},
111          {27, "daggers ", "", 0},
112          {35, "shurikens ", "", 0},
113         {360, "mace ", "", 0},
114         {470, "long sword ", "", 0},
115         {580, "two-handed sword ", "", 0}
116 };
117
118 struct id id_armors[ARMORS] = {
119         {300, "leather armor ", "", (UNIDENTIFIED)},
120         {300, "ring mail ", "", (UNIDENTIFIED)},
121         {400, "scale mail ", "", (UNIDENTIFIED)},
122         {500, "chain mail ", "", (UNIDENTIFIED)},
123         {600, "banded mail ", "", (UNIDENTIFIED)},
124         {600, "splint mail ", "", (UNIDENTIFIED)},
125         {700, "plate mail ", "", (UNIDENTIFIED)}
126 };
127
128 struct id id_wands[WANDS] = {
129          {25, "                                 ", "of teleport away ",0},
130          {50, "                                 ", "of slow monster ", 0},
131           {8, "                                 ", "of invisibility ",0},
132          {55, "                                 ", "of polymorph ",0},
133           {2, "                                 ", "of haste monster ",0},
134          {20, "                                 ", "of magic missile ",0},
135          {20, "                                 ", "of cancellation ",0},
136           {0, "                                 ", "of do nothing ",0},
137          {35, "                                 ", "of drain life ",0},
138          {20, "                                 ", "of cold ",0},
139          {20, "                                 ", "of fire ",0}
140 };
141
142 struct id id_rings[RINGS] = {
143          {250, "                                 ", "of stealth ",0},
144          {100, "                                 ", "of teleportation ", 0},
145          {255, "                                 ", "of regeneration ",0},
146          {295, "                                 ", "of slow digestion ",0},
147          {200, "                                 ", "of add strength ",0},
148          {250, "                                 ", "of sustain strength ",0},
149          {250, "                                 ", "of dexterity ",0},
150           {25, "                                 ", "of adornment ",0},
151          {300, "                                 ", "of see invisible ",0},
152          {290, "                                 ", "of maintain armor ",0},
153          {270, "                                 ", "of searching ",0},
154 };
155
156 extern short cur_level, max_level;
157 extern short party_room;
158 extern boolean is_wood[];
159
160 static void     put_gold(void);
161 static void     plant_gold(short, short, boolean);
162 static unsigned short   gr_what_is(void);
163 static void     gr_scroll(object *);
164 static void     gr_potion(object *);
165 static void     gr_weapon(object *, int);
166 static void     gr_armor(object *);
167 static void     gr_wand(object *);
168 static void     make_party(void);
169 static void     rand_place(object *);
170
171 void
172 put_objects(void)
173 {
174         short i, n;
175         object *obj;
176
177         if (cur_level < max_level) {
178                 return;
179         }
180         n = coin_toss() ? get_rand(2, 4) : get_rand(3, 5);
181         while (rand_percent(33)) {
182                 n++;
183         }
184         if (party_room != NO_ROOM) {
185                 make_party();
186         }
187         for (i = 0; i < n; i++) {
188                 obj = gr_object();
189                 rand_place(obj);
190         }
191         put_gold();
192 }
193
194 static void
195 put_gold(void)
196 {
197         short i, j;
198         short row,col;
199         boolean is_maze, is_room;
200
201         for (i = 0; i < MAXROOMS; i++) {
202                 is_maze = (rooms[i].is_room & R_MAZE) ? 1 : 0;
203                 is_room = (rooms[i].is_room & R_ROOM) ? 1 : 0;
204
205                 if (!(is_room || is_maze)) {
206                         continue;
207                 }
208                 if (is_maze || rand_percent(GOLD_PERCENT)) {
209                         for (j = 0; j < 50; j++) {
210                                 row = get_rand(rooms[i].top_row+1,
211                                 rooms[i].bottom_row-1);
212                                 col = get_rand(rooms[i].left_col+1,
213                                 rooms[i].right_col-1);
214                                 if ((dungeon[row][col] == FLOOR) ||
215                                         (dungeon[row][col] == TUNNEL)) {
216                                         plant_gold(row, col, is_maze);
217                                         break;
218                                 }
219                         }
220                 }
221         }
222 }
223
224 static void
225 plant_gold(short row, short col, boolean is_maze)
226 {
227         object *obj;
228
229         obj = alloc_object();
230         obj->row = row; obj->col = col;
231         obj->what_is = GOLD;
232         obj->quantity = get_rand((2 * cur_level), (16 * cur_level));
233         if (is_maze) {
234                 obj->quantity += obj->quantity / 2;
235         }
236         dungeon[row][col] |= OBJECT;
237         add_to_pack(obj, &level_objects, 0);
238 }
239
240 void
241 place_at(object *obj, int row, int col)
242 {
243         obj->row = row;
244         obj->col = col;
245         dungeon[row][col] |= OBJECT;
246         add_to_pack(obj, &level_objects, 0);
247 }
248
249 object *
250 object_at(object *pack, short row, short col)
251 {
252         object *obj = (object *) 0;
253
254         if (dungeon[row][col] & (MONSTER | OBJECT)) {
255                 obj = pack->next_object;
256
257                 while (obj && ((obj->row != row) || (obj->col != col))) {
258                         obj = obj->next_object;
259                 }
260                 if (!obj) {
261                         message("object_at(): inconsistent", 1);
262                 }
263         }
264         return(obj);
265 }
266
267 object *
268 get_letter_object(int ch)
269 {
270         object *obj;
271
272         obj = rogue.pack.next_object;
273
274         while (obj && (obj->ichar != ch)) {
275                 obj = obj->next_object;
276         }
277         return(obj);
278 }
279
280 void
281 free_stuff(object *objlist)
282 {
283         object *obj;
284
285         while (objlist->next_object) {
286                 obj = objlist->next_object;
287                 objlist->next_object =
288                         objlist->next_object->next_object;
289                 free_object(obj);
290         }
291 }
292
293 const char *
294 name_of(const object *obj)
295 {
296         const char *retstring;
297
298         switch(obj->what_is) {
299         case SCROL:
300                 retstring = obj->quantity > 1 ? "scrolls " : "scroll ";
301                 break;
302         case POTION:
303                 retstring = obj->quantity > 1 ? "potions " : "potion ";
304                 break;
305         case FOOD:
306                 if (obj->which_kind == RATION) {
307                         retstring = "food ";
308                 } else {
309                         retstring = fruit;
310                 }
311                 break;
312         case WAND:
313                 retstring = is_wood[obj->which_kind] ? "staff " : "wand ";
314                 break;
315         case WEAPON:
316                 switch(obj->which_kind) {
317                 case DART:
318                         retstring=obj->quantity > 1 ? "darts " : "dart ";
319                         break;
320                 case ARROW:
321                         retstring=obj->quantity > 1 ? "arrows " : "arrow ";
322                         break;
323                 case DAGGER:
324                         retstring=obj->quantity > 1 ? "daggers " : "dagger ";
325                         break;
326                 case SHURIKEN:
327                         retstring=obj->quantity > 1?"shurikens ":"shuriken ";
328                         break;
329                 default:
330                         retstring = id_weapons[obj->which_kind].title;
331                 }
332                 break;
333         case ARMOR:
334                 retstring = "armor ";
335                 break;
336         case RING:
337                         retstring = "ring ";
338                 break;
339         case AMULET:
340                 retstring = "amulet ";
341                 break;
342         default:
343                 retstring = "unknown ";
344                 break;
345         }
346         return(retstring);
347 }
348
349 object *
350 gr_object(void)
351 {
352         object *obj;
353
354         obj = alloc_object();
355
356         if (foods < (cur_level / 3)) {
357                 obj->what_is = FOOD;
358                 foods++;
359         } else {
360                 obj->what_is = gr_what_is();
361         }
362         switch(obj->what_is) {
363         case SCROL:
364                 gr_scroll(obj);
365                 break;
366         case POTION:
367                 gr_potion(obj);
368                 break;
369         case WEAPON:
370                 gr_weapon(obj, 1);
371                 break;
372         case ARMOR:
373                 gr_armor(obj);
374                 break;
375         case WAND:
376                 gr_wand(obj);
377                 break;
378         case FOOD:
379                 get_food(obj, 0);
380                 break;
381         case RING:
382                 gr_ring(obj, 1);
383                 break;
384         }
385         return(obj);
386 }
387
388 static unsigned short
389 gr_what_is(void)
390 {
391         short percent;
392         unsigned short what_is;
393
394         percent = get_rand(1, 91);
395
396         if (percent <= 30) {
397                 what_is = SCROL;
398         } else if (percent <= 60) {
399                 what_is = POTION;
400         } else if (percent <= 64) {
401                 what_is = WAND;
402         } else if (percent <= 74) {
403                 what_is = WEAPON;
404         } else if (percent <= 83) {
405                 what_is = ARMOR;
406         } else if (percent <= 88) {
407                 what_is = FOOD;
408         } else {
409                 what_is = RING;
410         }
411         return(what_is);
412 }
413
414 static void
415 gr_scroll(object *obj)
416 {
417         short percent;
418
419         percent = get_rand(0, 91);
420
421         obj->what_is = SCROL;
422
423         if (percent <= 5) {
424                 obj->which_kind = PROTECT_ARMOR;
425         } else if (percent <= 10) {
426                 obj->which_kind = HOLD_MONSTER;
427         } else if (percent <= 20) {
428                 obj->which_kind = CREATE_MONSTER;
429         } else if (percent <= 35) {
430                 obj->which_kind = IDENTIFY;
431         } else if (percent <= 43) {
432                 obj->which_kind = TELEPORT;
433         } else if (percent <= 50) {
434                 obj->which_kind = SLEEP;
435         } else if (percent <= 55) {
436                 obj->which_kind = SCARE_MONSTER;
437         } else if (percent <= 64) {
438                 obj->which_kind = REMOVE_CURSE;
439         } else if (percent <= 69) {
440                 obj->which_kind = ENCH_ARMOR;
441         } else if (percent <= 74) {
442                 obj->which_kind = ENCH_WEAPON;
443         } else if (percent <= 80) {
444                 obj->which_kind = AGGRAVATE_MONSTER;
445         } else if (percent <= 86) {
446                 obj->which_kind = CON_MON;
447         } else {
448                 obj->which_kind = MAGIC_MAPPING;
449         }
450 }
451
452 static void
453 gr_potion(object *obj)
454 {
455         short percent;
456
457         percent = get_rand(1, 118);
458
459         obj->what_is = POTION;
460
461         if (percent <= 5) {
462                 obj->which_kind = RAISE_LEVEL;
463         } else if (percent <= 15) {
464                 obj->which_kind = DETECT_OBJECTS;
465         } else if (percent <= 25) {
466                 obj->which_kind = DETECT_MONSTER;
467         } else if (percent <= 35) {
468                 obj->which_kind = INCREASE_STRENGTH;
469         } else if (percent <= 45) {
470                 obj->which_kind = RESTORE_STRENGTH;
471         } else if (percent <= 55) {
472                 obj->which_kind = HEALING;
473         } else if (percent <= 65) {
474                 obj->which_kind = EXTRA_HEALING;
475         } else if (percent <= 75) {
476                 obj->which_kind = BLINDNESS;
477         } else if (percent <= 85) {
478                 obj->which_kind = HALLUCINATION;
479         } else if (percent <= 95) {
480                 obj->which_kind = CONFUSION;
481         } else if (percent <= 105) {
482                 obj->which_kind = POISON;
483         } else if (percent <= 110) {
484                 obj->which_kind = LEVITATION;
485         } else if (percent <= 114) {
486                 obj->which_kind = HASTE_SELF;
487         } else {
488                 obj->which_kind = SEE_INVISIBLE;
489         }
490 }
491
492 static void
493 gr_weapon(object *obj, int assign_wk)
494 {
495         short percent;
496         short i;
497         short blessing, increment;
498
499         obj->what_is = WEAPON;
500         if (assign_wk) {
501                 obj->which_kind = get_rand(0, (WEAPONS - 1));
502         }
503         if ((obj->which_kind == ARROW) || (obj->which_kind == DAGGER) ||
504                 (obj->which_kind == SHURIKEN) | (obj->which_kind == DART)) {
505                 obj->quantity = get_rand(3, 15);
506                 obj->quiver = get_rand(0, 126);
507         } else {
508                 obj->quantity = 1;
509         }
510         obj->hit_enchant = obj->d_enchant = 0;
511
512         percent = get_rand(1, 96);
513         blessing = get_rand(1, 3);
514
515         if (percent <= 16) {
516                 increment = 1;
517         } else if (percent <= 32) {
518                 increment = -1;
519                 obj->is_cursed = 1;
520         }
521         if (percent <= 32) {
522                 for (i = 0; i < blessing; i++) {
523                         if (coin_toss()) {
524                                 obj->hit_enchant += increment;
525                         } else {
526                                 obj->d_enchant += increment;
527                         }
528                 }
529         }
530         switch(obj->which_kind) {
531         case BOW:
532         case DART:
533                 obj->damage = "1d1";
534                 break;
535         case ARROW:
536                 obj->damage = "1d2";
537                 break;
538         case DAGGER:
539                 obj->damage = "1d3";
540                 break;
541         case SHURIKEN:
542                 obj->damage = "1d4";
543                 break;
544         case MACE:
545                 obj->damage = "2d3";
546                 break;
547         case LONG_SWORD:
548                 obj->damage = "3d4";
549                 break;
550         case TWO_HANDED_SWORD:
551                 obj->damage = "4d5";
552                 break;
553         }
554 }
555
556 static void
557 gr_armor(object *obj)
558 {
559         short percent;
560         short blessing;
561
562         obj->what_is = ARMOR;
563         obj->which_kind = get_rand(0, (ARMORS - 1));
564         obj->class = obj->which_kind + 2;
565         if ((obj->which_kind == PLATE) || (obj->which_kind == SPLINT)) {
566                 obj->class--;
567         }
568         obj->is_protected = 0;
569         obj->d_enchant = 0;
570
571         percent = get_rand(1, 100);
572         blessing = get_rand(1, 3);
573
574         if (percent <= 16) {
575                 obj->is_cursed = 1;
576                 obj->d_enchant -= blessing;
577         } else if (percent <= 33) {
578                 obj->d_enchant += blessing;
579         }
580 }
581
582 static void
583 gr_wand(object *obj)
584 {
585         obj->what_is = WAND;
586         obj->which_kind = get_rand(0, (WANDS - 1));
587         obj->class = get_rand(3, 7);
588 }
589
590 void
591 get_food(object *obj, boolean force_ration)
592 {
593         obj->what_is = FOOD;
594
595         if (force_ration || rand_percent(80)) {
596                 obj->which_kind = RATION;
597         } else {
598                 obj->which_kind = FRUIT;
599         }
600 }
601
602 void
603 put_stairs(void)
604 {
605         short row, col;
606
607         gr_row_col(&row, &col, (FLOOR | TUNNEL));
608         dungeon[row][col] |= STAIRS;
609 }
610
611 short
612 get_armor_class(const object *obj)
613 {
614         if (obj) {
615                 return(obj->class + obj->d_enchant);
616         }
617         return(0);
618 }
619
620 object *
621 alloc_object(void)
622 {
623         object *obj;
624
625         if (free_list) {
626                 obj = free_list;
627                 free_list = free_list->next_object;
628         } else if (!(obj = (object *) md_malloc(sizeof(object)))) {
629                         message("cannot allocate object, saving game", 0);
630                         save_into_file(error_file);
631         }
632         obj->quantity = 1;
633         obj->ichar = 'L';
634         obj->picked_up = obj->is_cursed = 0;
635         obj->in_use_flags = NOT_USED;
636         obj->identified = UNIDENTIFIED;
637         obj->damage = "1d1";
638         return(obj);
639 }
640
641 void
642 free_object(object *obj)
643 {
644         obj->next_object = free_list;
645         free_list = obj;
646 }
647
648 static void
649 make_party(void)
650 {
651         short n;
652
653         party_room = gr_room();
654
655         n = rand_percent(99) ? party_objects(party_room) : 11;
656         if (rand_percent(99)) {
657                 party_monsters(party_room, n);
658         }
659 }
660
661 void
662 show_objects(void)
663 {
664         object *obj;
665         short mc, rc, row, col;
666         object *monster;
667
668         obj = level_objects.next_object;
669
670         while (obj) {
671                 row = obj->row;
672                 col = obj->col;
673
674                 rc = get_mask_char(obj->what_is);
675
676                 if (dungeon[row][col] & MONSTER) {
677                         if ((monster = object_at(&level_monsters, row, col))) {
678                                 monster->trail_char = rc;
679                         }
680                 }
681                 mc = mvinch(row, col);
682                 if (((mc < 'A') || (mc > 'Z')) &&
683                         ((row != rogue.row) || (col != rogue.col))) {
684                         mvaddch(row, col, rc);
685                 }
686                 obj = obj->next_object;
687         }
688
689         monster = level_monsters.next_object;
690
691         while (monster) {
692                 if (monster->m_flags & IMITATES) {
693                         mvaddch(monster->row, monster->col, (int) monster->disguise);
694                 }
695                 monster = monster->next_monster;
696         }
697 }
698
699 void
700 put_amulet(void)
701 {
702         object *obj;
703
704         obj = alloc_object();
705         obj->what_is = AMULET;
706         rand_place(obj);
707 }
708
709 static void
710 rand_place(object *obj)
711 {
712         short row, col;
713
714         gr_row_col(&row, &col, (FLOOR | TUNNEL));
715         place_at(obj, row, col);
716 }
717
718 void
719 c_object_for_wizard(void)
720 {
721         short ch, max = 0, wk;
722         object *obj;
723         char buf[80];
724
725         if (pack_count((object *) 0) >= MAX_PACK_COUNT) {
726                 message("pack full", 0);
727                 return;
728         }
729         message("type of object?", 0);
730
731         while (r_index("!?:)]=/,\033", (ch = rgetchar()), 0) == -1) {
732                 sound_bell();
733         }
734         check_message();
735
736         if (ch == '\033') {
737                 return;
738         }
739         obj = alloc_object();
740
741         switch(ch) {
742         case '!':
743                 obj->what_is = POTION;
744                 max = POTIONS - 1;
745                 break;
746         case '?':
747                 obj->what_is = SCROL;
748                 max = SCROLS - 1;
749                 break;
750         case ',':
751                 obj->what_is = AMULET;
752                 break;
753         case ':':
754                 get_food(obj, 0);
755                 break;
756         case ')':
757                 gr_weapon(obj, 0);
758                 max = WEAPONS - 1;
759                 break;
760         case ']':
761                 gr_armor(obj);
762                 max = ARMORS - 1;
763                 break;
764         case '/':
765                 gr_wand(obj);
766                 max = WANDS - 1;
767                 break;
768         case '=':
769                 max = RINGS - 1;
770                 obj->what_is = RING;
771                 break;
772         }
773         if ((ch != ',') && (ch != ':')) {
774 GIL:
775                 if (get_input_line("which kind?", "", buf, "", 0, 1)) {
776                         wk = get_number(buf);
777                         if ((wk >= 0) && (wk <= max)) {
778                                 obj->which_kind = (unsigned short) wk;
779                                 if (obj->what_is == RING) {
780                                         gr_ring(obj, 0);
781                                 }
782                         } else {
783                                 sound_bell();
784                                 goto GIL;
785                         }
786                 } else {
787                         free_object(obj);
788                         return;
789                 }
790         }
791         get_desc(obj, buf);
792         message(buf, 0);
793         add_to_pack(obj, &rogue.pack, 1);
794 }