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