ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/common/item.C
(Generate patch)

Comparing deliantra/server/common/item.C (file contents):
Revision 1.79 by root, Sun Apr 4 02:51:56 2010 UTC vs.
Revision 1.88 by root, Wed May 12 20:40:50 2010 UTC

… …
71static char numbers_10[10][20] = { 71static char numbers_10[10][20] = {
72 "zero", "ten", "twenty", "thirty", "fourty", "fifty", "sixty", "seventy", 72 "zero", "ten", "twenty", "thirty", "fourty", "fifty", "sixty", "seventy",
73 "eighty", "ninety" 73 "eighty", "ninety"
74}; 74};
75 75
76static char levelnumbers[21][20] = { 76static char ordnumbers[21][20] = {
77 "zeroth", "first", "second", "third", "fourth", "fifth", "sixth", "seventh", 77 "zeroth", "first", "second", "third", "fourth", "fifth", "sixth", "seventh",
78 "eighth", "ninth", "tenth", "eleventh", "twelfth", "thirteenth", 78 "eighth", "ninth", "tenth", "eleventh", "twelfth", "thirteenth",
79 "fourteenth", "fifteenth", "sixteenth", "seventeenth", "eighteen", 79 "fourteenth", "fifteenth", "sixteenth", "seventeenth", "eighteenth",
80 "nineteen", "twentieth" 80 "nineteenth", "twentieth"
81}; 81};
82 82
83static char levelnumbers_10[11][20] = { 83static char ordnumbers_10[11][20] = {
84 "zeroth", "tenth", "twentieth", "thirtieth", "fortieth", "fiftieth", "sixtieth", 84 "zeroth", "tenth", "twentieth", "thirtieth", "fortieth", "fiftieth", "sixtieth",
85 "seventieth", "eightieth", "ninetieth" 85 "seventieth", "eightieth", "ninetieth"
86}; 86};
87 87
88/* The following is a large table of item types, the fields are: 88/* The following is a large table of item types, the fields are:
… …
151 {EXIT, "exit", "exits", 0, 0}, 151 {EXIT, "exit", "exits", 0, 0},
152 {ENCOUNTER, "encounter", "encounters", 0, 0}, 152 {ENCOUNTER, "encounter", "encounters", 0, 0},
153 {SHOP_FLOOR, "shop floor", "shop floors", 0, 0}, 153 {SHOP_FLOOR, "shop floor", "shop floors", 0, 0},
154 {SHOP_MAT, "shop mat", "shop mats", 0, 0}, 154 {SHOP_MAT, "shop mat", "shop mats", 0, 0},
155 {RING, "ring", "rings", SK_JEWELER, 0}, 155 {RING, "ring", "rings", SK_JEWELER, 0},
156 {FLOOR, "floor", "floors", 0, 0}, 156// {FLOOR, "floor", "floors", 0, 0},
157 {FLESH, "flesh", "flesh", SK_WOODSMAN, 0}, 157 {FLESH, "flesh", "flesh", SK_WOODSMAN, 0},
158 {INORGANIC, "inorganic", "inorganics", SK_ALCHEMY, 0}, 158 {INORGANIC, "inorganic", "inorganics", SK_ALCHEMY, 0},
159 {SKILL_TOOL, "skill tool", "skill tools", 0, 0}, 159 {SKILL_TOOL, "skill tool", "skill tools", 0, 0},
160 {LIGHTER, "lighter", "lighters", 0, 0}, 160 {LIGHTER, "lighter", "lighters", 0, 0},
161 {BUILDABLE_WALL, "buildable wall", "buildable walls", 0, 0}, 161 {BUILDABLE_WALL, "buildable wall", "buildable walls", 0, 0},
… …
202 {BUILDER, "item builder", "item builders", 0, 0}, 202 {BUILDER, "item builder", "item builders", 0, 0},
203 {MATERIAL, "building material", "building materials", 0, 0}, 203 {MATERIAL, "building material", "building materials", 0, 0},
204 {ITEM_TRANSFORMER, "item_transformer", "item_transformers", 0, 0}, 204 {ITEM_TRANSFORMER, "item_transformer", "item_transformers", 0, 0},
205}; 205};
206 206
207static const int item_types_size = sizeof (item_types) / sizeof (*item_types); 207static const int item_types_size = array_length (item_types);
208 208
209/* This curve may be too steep. But the point is that there should 209/* This curve may be too steep. But the point is that there should
210 * be tough choices - there is no real point to this if everyone can 210 * be tough choices - there is no real point to this if everyone can
211 * wear whatever they want with no worries. Perhaps having the steep 211 * wear whatever they want with no worries. Perhaps having the steep
212 * curve is good (maybe even steeper), but allowing players to 212 * curve is good (maybe even steeper), but allowing players to
… …
214 * able to use 2-3 of the most powerful items. 214 * able to use 2-3 of the most powerful items.
215 * note that this table is only really used for program generated items - 215 * note that this table is only really used for program generated items -
216 * custom objects can use whatever they want. 216 * custom objects can use whatever they want.
217 */ 217 */
218static int enc_to_item_power[21] = { 218static int enc_to_item_power[21] = {
219 0,
219 0, 0, 1, 2, 3, 4, /* 5 */ 220 0, 1, 2, 3, 4, // 5
220 5, 7, 9, 11, 13, /* 10 */ 221 5, 7, 9, 11, 13, // 10
221 15, 18, 21, 24, 27, /* 15 */ 222 15, 18, 21, 24, 27, // 15
222 30, 35, 40, 45, 50 /* 20 */ 223 30, 35, 40, 45, 50 // 20
223}; 224};
224 225
225int 226int
226get_power_from_ench (int ench) 227get_power_from_ench (int ench)
227{ 228{
228 return enc_to_item_power [clamp (ench, 0, 20)]; 229 return enc_to_item_power [clamp (ench, 0, 20)];
230}
231
232static const struct need_identify_types : typeset
233{
234 need_identify_types ()
235 {
236 set (RING);
237 set (WAND);
238 set (ROD);
239 set (HORN);
240 set (SCROLL);
241 set (SKILL);
242 set (SKILLSCROLL);
243 set (SPELLBOOK);
244 set (FOOD);
245 set (POTION);
246 set (BOW);
247 set (ARROW);
248 set (WEAPON);
249 set (ARMOUR);
250 set (SHIELD);
251 set (HELMET);
252 set (AMULET);
253 set (BOOTS);
254 set (GLOVES);
255 set (BRACERS);
256 set (GIRDLE);
257 set (CONTAINER);
258 set (DRINK);
259 set (FLESH);
260 set (INORGANIC);
261 set (CLOSE_CON);
262 set (CLOAK);
263 set (GEM);
264 set (POWER_CRYSTAL);
265 set (POISON);
266 set (BOOK);
267 set (SKILL_TOOL);
268 }
269} need_identify_types;
270
271bool
272object::need_identify () const
273{
274 return need_identify_types [type];
229} 275}
230 276
231/* This takes an object 'op' and figures out what its item_power 277/* This takes an object 'op' and figures out what its item_power
232 * rating should be. This should only really be used by the treasure 278 * rating should be. This should only really be used by the treasure
233 * generation code, and when loading legacy objects. It returns 279 * generation code, and when loading legacy objects. It returns
… …
307 if (op->flag [FLAG_MAKE_INVIS ]) enc += 1; 353 if (op->flag [FLAG_MAKE_INVIS ]) enc += 1;
308 354
309 return get_power_from_ench (enc); 355 return get_power_from_ench (enc);
310} 356}
311 357
358static const struct get_typedata
359{
360 const typedata *data [NUM_TYPES];
361
362 get_typedata ()
363 {
364 for (int i = 0; i < item_types_size; i++)
365 data [item_types[i].number] = &item_types [i];
366 }
367
368 const typedata *operator ()(int itemtype) const
369 {
370 return data [itemtype];
371 }
372} get_typedata_;
373
312/* returns the typedata that has a number equal to itemtype, if there 374/* returns the typedata that has a number equal to itemtype, if there
313 * isn't one, returns NULL */ 375 * isn't one, returns NULL */
314const typedata * 376const typedata *
315get_typedata (int itemtype) 377get_typedata (int itemtype)
316{ 378{
317 for (int i = 0; i < item_types_size; i++) 379 return get_typedata_ (itemtype);
318 if (item_types[i].number == itemtype)
319 return &item_types[i];
320
321 return NULL;
322} 380}
323 381
324/* returns the typedata that has a name equal to itemtype, if there 382/* returns the typedata that has a name equal to itemtype, if there
325 * isn't one, return the plural name that matches, if there still isn't 383 * isn't one, return the plural name that matches, if there still isn't
326 * one return NULL */ 384 * one return NULL */
… …
387/* 445/*
388 * Returns the pointer to a static buffer containing 446 * Returns the pointer to a static buffer containing
389 * the number requested (of the form first, second, third...) 447 * the number requested (of the form first, second, third...)
390 */ 448 */
391const char * 449const char *
392get_levelnumber (int i) 450ordinal (int i)
393{ 451{
394 static char buf[MAX_BUF]; 452 if (i < 0)
395 453 return format ("minus %s", ordinal (-i));
396 if (i > 99)
397 {
398 sprintf (buf, "%d.", i);
399 return buf;
400 }
401 454
402 if (i < 21) 455 if (i < 21)
403 return levelnumbers[i]; 456 return ordnumbers[i];
404 457
458 int digit = i % 10;
459
405 if (!(i % 10)) 460 if (i >= 100)
461 return format (
462 digit == 1 ? "%dst"
463 : digit == 2 ? "%dnd"
464 : digit == 3 ? "%drd"
465 : "%dth",
466 i
467 );
468
469 if (digit == 0)
406 return levelnumbers_10[i / 10]; 470 return ordnumbers_10[i / 10];
407 471 else
408 strcpy (buf, numbers_10[i / 10]); 472 return format ("%s%s", numbers_10[i / 10], ordnumbers[i % 10]);
409 strcat (buf, levelnumbers[i % 10]);
410 return buf;
411} 473}
412 474
413/* 475/*
414 * Returns pointer to static buffer containing ring's or amulet's 476 * Returns pointer to static buffer containing ring's or amulet's
415 * abilities 477 * abilities
… …
427ring_desc (const object *op) 489ring_desc (const object *op)
428{ 490{
429 static dynbuf_text buf; buf.clear (); 491 static dynbuf_text buf; buf.clear ();
430 int attr, val, len; 492 int attr, val, len;
431 493
432 if (QUERY_FLAG (op, FLAG_IDENTIFIED)) 494 if (op->flag [FLAG_IDENTIFIED])
433 { 495 {
434 for (attr = 0; attr < NUM_STATS; attr++) 496 for (attr = 0; attr < NUM_STATS; attr++)
435 if ((val = op->stats.stat (attr))) 497 if ((val = op->stats.stat (attr)))
436 buf.printf ("(%s%+d)", short_stat_name[attr], val); 498 buf.printf ("(%s%+d)", short_stat_name[attr], val);
437 499
438 if (op->stats.exp) buf.printf ("(speed %+lld)", (long long)op->stats.exp); 500 if (op->stats.exp) buf.printf ("(speed %+d)", (int)op->stats.exp);
439 if (op->stats.wc) buf.printf ("(wc%+d)", op->stats.wc); 501 if (op->stats.wc) buf.printf ("(wc%+d)", op->stats.wc);
440 if (op->stats.dam) buf.printf ("(dam%+d)", op->stats.dam); 502 if (op->stats.dam) buf.printf ("(dam%+d)", op->stats.dam);
441 if (op->stats.ac) buf.printf ("(ac%+d)", op->stats.ac); 503 if (op->stats.ac) buf.printf ("(ac%+d)", op->stats.ac);
442 504
443 buf << describe_resistance (op, 0); 505 buf << describe_resistance (op, 0);
… …
446 if (op->stats.grace) buf.printf ("(grace%+d)", op->stats.grace); 508 if (op->stats.grace) buf.printf ("(grace%+d)", op->stats.grace);
447 if (op->stats.sp && op->type != SKILL) buf.printf ("(magic%+d)", op->stats.sp); 509 if (op->stats.sp && op->type != SKILL) buf.printf ("(magic%+d)", op->stats.sp);
448 if (op->stats.hp) buf.printf ("(regeneration%+d)", op->stats.hp); 510 if (op->stats.hp) buf.printf ("(regeneration%+d)", op->stats.hp);
449 if (op->stats.luck) buf.printf ("(luck%+d)", op->stats.luck); 511 if (op->stats.luck) buf.printf ("(luck%+d)", op->stats.luck);
450 512
451 if (QUERY_FLAG (op, FLAG_LIFESAVE)) buf << "(lifesaving)"; 513 if (op->flag [FLAG_LIFESAVE]) buf << "(lifesaving)";
452 if (QUERY_FLAG (op, FLAG_REFL_SPELL)) buf << "(reflect spells)"; 514 if (op->flag [FLAG_REFL_SPELL]) buf << "(reflect spells)";
453 if (QUERY_FLAG (op, FLAG_REFL_MISSILE)) buf << "(reflect missiles)"; 515 if (op->flag [FLAG_REFL_MISSILE]) buf << "(reflect missiles)";
454 if (QUERY_FLAG (op, FLAG_STEALTH)) buf << "(stealth)"; 516 if (op->flag [FLAG_STEALTH]) buf << "(stealth)";
455 517
456 buf.add_paths ("Attuned" , op->path_attuned); 518 buf.add_paths ("Attuned" , op->path_attuned);
457 buf.add_paths ("Repelled", op->path_repelled); 519 buf.add_paths ("Repelled", op->path_repelled);
458 buf.add_paths ("Denied" , op->path_denied); 520 buf.add_paths ("Denied" , op->path_denied);
459 521
… …
485 547
486 static dynbuf_text buf; buf.clear (); 548 static dynbuf_text buf; buf.clear ();
487 549
488 buf << (op->nrof <= 1 ? op->name : op->name_pl); 550 buf << (op->nrof <= 1 ? op->name : op->name_pl);
489 551
490 if (op->title && QUERY_FLAG (op, FLAG_IDENTIFIED)) 552 if (op->title && op->flag [FLAG_IDENTIFIED])
491 buf << ' ' << op->title; 553 buf << ' ' << op->title;
492 554
493 switch (op->type) 555 switch (op->type)
494 { 556 {
495 case SPELLBOOK: 557 case SPELLBOOK:
496 case SCROLL: 558 case SCROLL:
497 case WAND: 559 case WAND:
498 case ROD: 560 case ROD:
499 if (QUERY_FLAG (op, FLAG_IDENTIFIED) || QUERY_FLAG (op, FLAG_BEEN_APPLIED)) 561 if (op->flag [FLAG_IDENTIFIED] || op->flag [FLAG_BEEN_APPLIED])
500 { 562 {
501 if (!op->title) 563 if (!op->title)
502 buf << " of " << (op->inv ? &op->inv->name : "bug, please report"); 564 buf << " of " << (op->inv ? &op->inv->name : "bug, please report");
503 565
504 if (op->type != SPELLBOOK) 566 if (op->type != SPELLBOOK)
… …
543 buf << " " << s; 605 buf << " " << s;
544 } 606 }
545 break; 607 break;
546 608
547 default: 609 default:
548 if (op->magic && ((QUERY_FLAG (op, FLAG_BEEN_APPLIED) && need_identify (op)) || QUERY_FLAG (op, FLAG_IDENTIFIED))) 610 if (op->magic
611 && ((op->flag [FLAG_BEEN_APPLIED] && op->need_identify ())
612 || op->flag [FLAG_IDENTIFIED]))
549 buf.printf (" %+d", op->magic); 613 buf.printf (" %+d", op->magic);
550 } 614 }
551 615
552 return buf; 616 return buf;
553} 617}
… …
584 buf << op->material->description << ' '; 648 buf << op->material->description << ' ';
585#endif 649#endif
586 650
587 buf << query_short_name (op); 651 buf << query_short_name (op);
588 652
589 if (QUERY_FLAG (op, FLAG_INV_LOCKED)) 653 if (op->flag [FLAG_INV_LOCKED])
590 buf << " *"; 654 buf << " *";
591 if (op->is_open_container ()) 655 if (op->is_open_container ())
592 buf << " (open)"; 656 buf << " (open)";
593 657
594 if (QUERY_FLAG (op, FLAG_KNOWN_CURSED)) 658 if (op->flag [FLAG_KNOWN_CURSED])
595 { 659 {
596 if (QUERY_FLAG (op, FLAG_DAMNED)) 660 if (op->flag [FLAG_DAMNED])
597 buf << " (damned)"; 661 buf << " (damned)";
598 else if (QUERY_FLAG (op, FLAG_CURSED)) 662 else if (op->flag [FLAG_CURSED])
599 buf << " (cursed)"; 663 buf << " (cursed)";
600 } 664 }
601 665
602 /* Basically, if the object is known magical (detect magic spell on it), 666 /* Basically, if the object is known magical (detect magic spell on it),
603 * and it isn't identified, print out the fact that 667 * and it isn't identified, print out the fact that
… …
606 * 670 *
607 * Changed in V 0.91.4 - still print that the object is magical even 671 * Changed in V 0.91.4 - still print that the object is magical even
608 * if it has been applied. Equipping an item does not tell full 672 * if it has been applied. Equipping an item does not tell full
609 * abilities, especially for artifact items. 673 * abilities, especially for artifact items.
610 */ 674 */
611 if (QUERY_FLAG (op, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (op, FLAG_IDENTIFIED)) 675 if (op->flag [FLAG_KNOWN_MAGICAL] && !op->flag [FLAG_IDENTIFIED])
612 buf << " (magic)"; 676 buf << " (magic)";
613 677
614#if 0 678#if 0
615 /* item_power will be returned in describe_item - it shouldn't really 679 /* item_power will be returned in describe_item - it shouldn't really
616 * be returned in the name. 680 * be returned in the name.
… …
618 if (op->item_power) 682 if (op->item_power)
619 sprintf (buf[use_buf] + strlen (buf[use_buf]), "(item_power %+d)", op->item_power); 683 sprintf (buf[use_buf] + strlen (buf[use_buf]), "(item_power %+d)", op->item_power);
620 684
621#endif 685#endif
622 686
623 if (QUERY_FLAG (op, FLAG_APPLIED)) 687 if (op->flag [FLAG_APPLIED])
624 { 688 {
625 switch (op->type) 689 switch (op->type)
626 { 690 {
627 case BOW: 691 case BOW:
628 case WAND: 692 case WAND:
… …
671 else if (op->stats.food <= 0) 735 else if (op->stats.food <= 0)
672 buf << " (burned out)"; 736 buf << " (burned out)";
673 break; 737 break;
674 } 738 }
675 739
676 if (QUERY_FLAG (op, FLAG_UNPAID)) 740 if (op->flag [FLAG_UNPAID])
677 buf << " (unpaid)"; 741 buf << " (unpaid)";
678 742
679 return buf; 743 return buf;
680} 744}
681 745
… …
710 buf << op->material->description << ' '; 774 buf << op->material->description << ' ';
711#endif 775#endif
712 776
713 buf << (plural ? op->name_pl : op->name); 777 buf << (plural ? op->name_pl : op->name);
714 778
715 if (op->title && QUERY_FLAG (op, FLAG_IDENTIFIED)) 779 if (op->title && op->flag [FLAG_IDENTIFIED])
716 buf << ' ' << op->title; 780 buf << ' ' << op->title;
717 781
718 switch (op->type) 782 switch (op->type)
719 { 783 {
720 case SPELLBOOK: 784 case SPELLBOOK:
721 case SCROLL: 785 case SCROLL:
722 case WAND: 786 case WAND:
723 case ROD: 787 case ROD:
724 if (QUERY_FLAG (op, FLAG_IDENTIFIED) || QUERY_FLAG (op, FLAG_BEEN_APPLIED)) 788 if (op->flag [FLAG_IDENTIFIED] || op->flag [FLAG_BEEN_APPLIED])
725 { 789 {
726 if (!op->title) 790 if (!op->title)
727 buf << " of " << (op->inv ? &op->inv->name : "bug, please report"); 791 buf << " of " << (op->inv ? &op->inv->name : "bug, please report");
728 792
729 if (op->type != SPELLBOOK) 793 if (op->type != SPELLBOOK)
… …
752 else if (!EXIT_PATH (op)) 816 else if (!EXIT_PATH (op))
753 buf << " (closed)"; 817 buf << " (closed)";
754 break; 818 break;
755 819
756 default: 820 default:
757 if (op->magic && ((QUERY_FLAG (op, FLAG_BEEN_APPLIED) && need_identify (op)) || QUERY_FLAG (op, FLAG_IDENTIFIED))) 821 if (op->magic
822 && ((op->flag [FLAG_BEEN_APPLIED] && op->need_identify ())
823 || op->flag [FLAG_IDENTIFIED]))
758 buf.printf (" %+d", op->magic); 824 buf.printf (" %+d", op->magic);
759 } 825 }
760 826
761 return buf; 827 return buf;
762} 828}
… …
805 default: 871 default:
806 buf << "(lightning fast movement)"; 872 buf << "(lightning fast movement)";
807 break; 873 break;
808 } 874 }
809 875
810 if (QUERY_FLAG (op, FLAG_UNDEAD)) buf << "(undead)"; 876 if (op->flag [FLAG_UNDEAD]) buf << "(undead)";
811 if (QUERY_FLAG (op, FLAG_SEE_INVISIBLE)) buf << "(see invisible)"; 877 if (op->flag [FLAG_SEE_INVISIBLE]) buf << "(see invisible)";
812 if (QUERY_FLAG (op, FLAG_USE_WEAPON)) buf << "(wield weapon)"; 878 if (op->flag [FLAG_USE_WEAPON]) buf << "(wield weapon)";
813 if (QUERY_FLAG (op, FLAG_USE_BOW)) buf << "(archer)"; 879 if (op->flag [FLAG_USE_BOW]) buf << "(archer)";
814 if (QUERY_FLAG (op, FLAG_USE_ARMOUR)) buf << "(wear armour)"; 880 if (op->flag [FLAG_USE_ARMOUR]) buf << "(wear armour)";
815 if (QUERY_FLAG (op, FLAG_USE_RING)) buf << "(wear ring)"; 881 if (op->flag [FLAG_USE_RING]) buf << "(wear ring)";
816 if (QUERY_FLAG (op, FLAG_USE_SCROLL)) buf << "(read scroll)"; 882 if (op->flag [FLAG_USE_SCROLL]) buf << "(read scroll)";
817 if (QUERY_FLAG (op, FLAG_USE_RANGE)) buf << "(fires wand/rod/horn)"; 883 if (op->flag [FLAG_USE_RANGE]) buf << "(fires wand/rod/horn)";
818 if (QUERY_FLAG (op, FLAG_CAN_USE_SKILL)) buf << "(skill user)"; 884 if (op->flag [FLAG_CAN_USE_SKILL]) buf << "(skill user)";
819 if (QUERY_FLAG (op, FLAG_CAST_SPELL)) buf << "(spellcaster)"; 885 if (op->flag [FLAG_CAST_SPELL]) buf << "(spellcaster)";
820 if (QUERY_FLAG (op, FLAG_FRIENDLY)) buf << "(friendly)"; 886 if (op->flag [FLAG_FRIENDLY]) buf << "(friendly)";
821 if (QUERY_FLAG (op, FLAG_UNAGGRESSIVE)) buf << "(unaggressive)"; 887 if (op->flag [FLAG_UNAGGRESSIVE]) buf << "(unaggressive)";
822 if (QUERY_FLAG (op, FLAG_HITBACK)) buf << "(hitback)"; 888 if (op->flag [FLAG_HITBACK]) buf << "(hitback)";
823 if (QUERY_FLAG (op, FLAG_STEALTH)) buf << "(stealthy)"; 889 if (op->flag [FLAG_STEALTH]) buf << "(stealthy)";
824 890
825 if (op->randomitems) 891 if (op->randomitems)
826 { 892 {
827 bool first = 1; 893 bool first = 1;
828 894
… …
910 * item (eg, debug dump or the like) 976 * item (eg, debug dump or the like)
911 */ 977 */
912const char * 978const char *
913describe_item (const object *op, object *owner) 979describe_item (const object *op, object *owner)
914{ 980{
915 if (QUERY_FLAG (op, FLAG_MONSTER) || op->type == PLAYER) 981 if (op->flag [FLAG_MONSTER] || op->type == PLAYER)
916 return describe_monster (op); 982 return describe_monster (op);
917 983
918 static dynbuf_text buf; buf.clear (); 984 static dynbuf_text buf; buf.clear ();
919 int identified, i; 985 int identified, i;
920 986
921 /* figure this out once, instead of making multiple calls to need_identify. 987 /* figure this out once, instead of making multiple calls to need_identify.
922 * also makes the code easier to read. 988 * also makes the code easier to read.
923 */ 989 */
924 identified = !need_identify (op) || QUERY_FLAG (op, FLAG_IDENTIFIED); 990 identified = !op->need_identify () || op->flag [FLAG_IDENTIFIED];
925 if (!identified) 991 if (!identified)
926 buf << "(unidentified)"; 992 buf << "(unidentified)";
927 993
928 switch (op->type) 994 switch (op->type)
929 { 995 {
… …
999 break; 1065 break;
1000 1066
1001 case FOOD: 1067 case FOOD:
1002 case FLESH: 1068 case FLESH:
1003 case DRINK: 1069 case DRINK:
1004 if (identified || QUERY_FLAG (op, FLAG_BEEN_APPLIED)) 1070 if (identified || op->flag [FLAG_BEEN_APPLIED])
1005 { 1071 {
1006 buf.printf ("(food+%d)", op->stats.food); 1072 buf.printf ("(food+%d)", op->stats.food);
1007 1073
1008 if (op->type == FLESH && op->last_eat > 0 && atnr_is_dragon_enabled (op->last_eat)) 1074 if (op->type == FLESH && op->last_eat > 0 && atnr_is_dragon_enabled (op->last_eat))
1009 buf.printf ("(%s metabolism)", change_resist_msg[op->last_eat]); 1075 buf.printf ("(%s metabolism)", change_resist_msg[op->last_eat]);
1010 1076
1011 if (!QUERY_FLAG (op, FLAG_CURSED)) 1077 if (!op->flag [FLAG_CURSED])
1012 { 1078 {
1013 if (op->stats.hp) buf << "(heals)"; 1079 if (op->stats.hp) buf << "(heals)";
1014 if (op->stats.sp) buf << "(spellpoint regen)"; 1080 if (op->stats.sp) buf << "(spellpoint regen)";
1015 } 1081 }
1016 else 1082 else
… …
1037 } 1103 }
1038 1104
1039 /* Down here, we more further describe equipment type items. 1105 /* Down here, we more further describe equipment type items.
1040 * only describe them if they have been identified or the like. 1106 * only describe them if they have been identified or the like.
1041 */ 1107 */
1042 if (identified || QUERY_FLAG (op, FLAG_BEEN_APPLIED)) 1108 if (identified || op->flag [FLAG_BEEN_APPLIED])
1043 { 1109 {
1044 int attr, val; 1110 int attr, val;
1045 1111
1046 for (attr = 0; attr < NUM_STATS; attr++) 1112 for (attr = 0; attr < NUM_STATS; attr++)
1047 if ((val = op->stats.stat (attr))) 1113 if ((val = op->stats.stat (attr)))
… …
1078 1144
1079 default: 1145 default:
1080 break; 1146 break;
1081 } 1147 }
1082 1148
1083 if (QUERY_FLAG (op, FLAG_XRAYS)) buf << "(xray-vision)"; 1149 if (op->flag [FLAG_XRAYS]) buf << "(xray-vision)";
1084 if (QUERY_FLAG (op, FLAG_SEE_IN_DARK)) buf << "(infravision)"; 1150 if (op->flag [FLAG_SEE_IN_DARK]) buf << "(infravision)";
1085 1151
1086 /* levitate was what is was before, so we'll keep it */ 1152 /* levitate was what is was before, so we'll keep it */
1087 if (op->move_type & MOVE_FLY_LOW) buf << "(levitate)"; 1153 if (op->move_type & MOVE_FLY_LOW) buf << "(levitate)";
1088 if (op->move_type & MOVE_FLY_HIGH) buf << "(fly)"; 1154 if (op->move_type & MOVE_FLY_HIGH) buf << "(fly)";
1089 if (op->move_type & MOVE_SWIM) buf << "(swim)"; 1155 if (op->move_type & MOVE_SWIM) buf << "(swim)";
… …
1151 } 1217 }
1152 1218
1153 if (op->stats.luck) 1219 if (op->stats.luck)
1154 buf.printf ("(luck%+d)", op->stats.luck); 1220 buf.printf ("(luck%+d)", op->stats.luck);
1155 1221
1156 if (QUERY_FLAG (op, FLAG_LIFESAVE)) buf << "(lifesaving)"; 1222 if (op->flag [FLAG_LIFESAVE]) buf << "(lifesaving)";
1157 if (QUERY_FLAG (op, FLAG_REFL_SPELL)) buf << "(reflect spells)"; 1223 if (op->flag [FLAG_REFL_SPELL]) buf << "(reflect spells)";
1158 if (QUERY_FLAG (op, FLAG_REFL_MISSILE)) buf << "(reflect missiles)"; 1224 if (op->flag [FLAG_REFL_MISSILE]) buf << "(reflect missiles)";
1159 if (QUERY_FLAG (op, FLAG_STEALTH)) buf << "(stealth)"; 1225 if (op->flag [FLAG_STEALTH]) buf << "(stealth)";
1160 1226
1161 if (op->slaying && op->type != FOOD) 1227 if (op->slaying && op->type != FOOD)
1162 buf.printf ("(slay %s)", &op->slaying); 1228 buf.printf ("(slay %s)", &op->slaying);
1163 1229
1164 if (op->type == SKILL_TOOL && op->skill) 1230 if (op->type == SKILL_TOOL && op->skill)
… …
1208 1274
1209 switch (type) 1275 switch (type)
1210 { 1276 {
1211 case SPELLBOOK: 1277 case SPELLBOOK:
1212 if (flag [FLAG_IDENTIFIED] && inv) 1278 if (flag [FLAG_IDENTIFIED] && inv)
1213 buf.printf ("%s is a level %s %s spell.\r", &inv->name, get_levelnumber (inv->level), &inv->skill); 1279 buf.printf ("%s is a %s level %s spell.\r", &inv->name, ordinal (inv->level), &inv->skill);
1214 break; 1280 break;
1215 1281
1216 case BOOK: 1282 case BOOK:
1217 if (msg) 1283 if (msg)
1218 buf << "Something is written in it.\r"; 1284 buf << "Something is written in it.\r";
… …
1287 */ 1353 */
1288 if (msg) 1354 if (msg)
1289 { 1355 {
1290 if (type != EXIT && type != BOOK && type != CORPSE && !move_on && !has_dialogue ()) 1356 if (type != EXIT && type != BOOK && type != CORPSE && !move_on && !has_dialogue ())
1291 { 1357 {
1292 buf << '\r'; 1358 if (!need_identify ())
1293 1359 buf << '\r' << msg << '\n';
1294 /* This is just a hack so when identifying the items, we print 1360 else if (flag [FLAG_IDENTIFIED])
1295 * out the extra message
1296 */
1297 if (need_identify (this) && flag [FLAG_IDENTIFIED])
1298 buf << "The object has a story:\r"; 1361 buf << '\r' << "The object has a story:\r" << msg;
1299
1300 buf << msg << '\n';
1301 } 1362 }
1302 } 1363 }
1303 else if (inv && inv->type == SPELL && flag [FLAG_IDENTIFIED] 1364 else if (inv
1365 && inv->msg
1366 && inv->type == SPELL
1367 && flag [FLAG_IDENTIFIED]
1304 && (type == SPELLBOOK || type == ROD || type == WAND 1368 && (type == SPELLBOOK || type == ROD || type == WAND
1305 || type == ROD || type == POTION || type == SCROLL)) 1369 || type == ROD || type == POTION || type == SCROLL))
1306 // for spellbooks and other stuff that contains spells, print the spell message, 1370 // for spellbooks and other stuff that contains spells, print the spell message,
1307 // unless the object has a custom message handled above. 1371 // unless the object has a custom message handled above.
1308 buf << '\r' << inv->msg << '\n'; 1372 buf << '\r' << inv->msg << '\n';
… …
1321 if (spell->subtype == SP_CHANGE_ABILITY) 1385 if (spell->subtype == SP_CHANGE_ABILITY)
1322 buf.printf ("\nH<The effect will last about %.10g seconds.>", 1386 buf.printf ("\nH<The effect will last about %.10g seconds.>",
1323 TICK2TIME (change_ability_duration (spell, this))); 1387 TICK2TIME (change_ability_duration (spell, this)));
1324 } 1388 }
1325 1389
1390 // some help text for skill tools
1391 if (type == SKILL_TOOL)
1392 buf << "\nH<This item is a skill tool: as long as you have this item applied "
1393 "you can use the " << &skill << " skill as if you had learned it.>";
1394
1326 // Display a hint about inscribable items [empty books] 1395 // Display a hint about inscribable items [empty books]
1327 // This includes the amount of text they can hold. 1396 // This includes the amount of text they can hold.
1328 if (type == INSCRIBABLE) 1397 if (type == INSCRIBABLE)
1329 { 1398 {
1330 if (other_arch && other_arch->type == SCROLL) 1399 if (other_arch && other_arch->type == SCROLL)
… …
1369object::query_inventory (object *who, const char *indent) 1438object::query_inventory (object *who, const char *indent)
1370{ 1439{
1371 static dynbuf_text buf; buf.clear (); 1440 static dynbuf_text buf; buf.clear ();
1372 1441
1373 for (object *tmp = inv; tmp; tmp = tmp->below) 1442 for (object *tmp = inv; tmp; tmp = tmp->below)
1374 if (who && QUERY_FLAG (who, FLAG_WIZ)) 1443 if (who && who->flag [FLAG_WIZ])
1375 buf.printf ("%s- %-28.28s %-8s (%9d) %s\n", indent, tmp->query_name (), tmp->query_weight (), tmp->count, tmp->uuid.c_str ()); 1444 buf.printf ("%s- %-28.28s %-8s (%9d) %s\n", indent, tmp->query_name (), tmp->query_weight (), tmp->count, tmp->uuid.c_str ());
1376 else if (!tmp->invisible && (type == CONTAINER || QUERY_FLAG (tmp, FLAG_APPLIED))) 1445 else if (!tmp->invisible && (type == CONTAINER || tmp->flag [FLAG_APPLIED]))
1377 buf.printf ("%s- %-36.36s %-8s\n", indent, tmp->query_name (), tmp->query_weight ()); 1446 buf.printf ("%s- %-36.36s %-8s\n", indent, tmp->query_name (), tmp->query_weight ());
1378 1447
1379 if (buf.size ()) 1448 if (buf.size ())
1380 buf.printf ("%s(total weight: %s)\n", indent, query_weight ()); 1449 buf.printf ("%s(total weight: %s)\n", indent, query_weight ());
1381 else 1450 else
… …
1394is_magical (const object *op) 1463is_magical (const object *op)
1395{ 1464{
1396 int i; 1465 int i;
1397 1466
1398 /* living creatures are considered non magical */ 1467 /* living creatures are considered non magical */
1399 if (QUERY_FLAG (op, FLAG_ALIVE)) 1468 if (op->flag [FLAG_ALIVE])
1400 return 0; 1469 return 0;
1401 1470
1402 /* This is a test for it being an artifact, as artifacts have titles */ 1471 /* This is a test for it being an artifact, as artifacts have titles */
1403 if (op->title != NULL) 1472 if (op->title != NULL)
1404 return 1; 1473 return 1;
… …
1410 (op->stats.ac || op->stats.food || op->stats.exp || op->stats.dam || op->stats.wc || op->stats.sp || op->stats.hp || op->stats.luck)) 1479 (op->stats.ac || op->stats.food || op->stats.exp || op->stats.dam || op->stats.wc || op->stats.sp || op->stats.hp || op->stats.luck))
1411 return 1; 1480 return 1;
1412 1481
1413 /* Check for stealty, speed, flying, or just plain magic in the boots */ 1482 /* Check for stealty, speed, flying, or just plain magic in the boots */
1414 /* Presume any boots that hvae a move_type are special. */ 1483 /* Presume any boots that hvae a move_type are special. */
1415 if (op->type == BOOTS && ((QUERY_FLAG (op, FLAG_STEALTH) || op->move_type || op->stats.exp))) 1484 if (op->type == BOOTS && ((op->flag [FLAG_STEALTH] || op->move_type || op->stats.exp)))
1416 return 1; 1485 return 1;
1417 1486
1418 /* Take care of amulet/shield that reflects spells/missiles */ 1487 /* Take care of amulet/shield that reflects spells/missiles */
1419 if ((op->type == AMULET || op->type == SHIELD) && (QUERY_FLAG (op, FLAG_REFL_SPELL) || QUERY_FLAG (op, FLAG_REFL_MISSILE))) 1488 if ((op->type == AMULET || op->type == SHIELD) && (op->flag [FLAG_REFL_SPELL] || op->flag [FLAG_REFL_MISSILE]))
1420 return 1; 1489 return 1;
1421 1490
1422 /* Take care of helmet of xrays */ 1491 /* Take care of helmet of xrays */
1423 if (op->type == HELMET && QUERY_FLAG (op, FLAG_XRAYS)) 1492 if (op->type == HELMET && op->flag [FLAG_XRAYS])
1424 return 1; 1493 return 1;
1425 1494
1426 /* Potions & rods are always magical. Wands/staves are also magical, 1495 /* Potions & rods are always magical. Wands/staves are also magical,
1427 * assuming they still have any charges left. 1496 * assuming they still have any charges left.
1428 */ 1497 */
… …
1457 * be non magical. 1526 * be non magical.
1458 */ 1527 */
1459 return 0; 1528 return 0;
1460} 1529}
1461 1530
1462/* need_identify returns true if the item should be identified. This
1463 * function really should not exist - by default, any item not identified
1464 * should need it.
1465 */
1466
1467int
1468need_identify (const object *op)
1469{
1470 switch (op->type)
1471 {
1472 case RING:
1473 case WAND:
1474 case ROD:
1475 case HORN:
1476 case SCROLL:
1477 case SKILL:
1478 case SKILLSCROLL:
1479 case SPELLBOOK:
1480 case FOOD:
1481 case POTION:
1482 case BOW:
1483 case ARROW:
1484 case WEAPON:
1485 case ARMOUR:
1486 case SHIELD:
1487 case HELMET:
1488 case AMULET:
1489 case BOOTS:
1490 case GLOVES:
1491 case BRACERS:
1492 case GIRDLE:
1493 case CONTAINER:
1494 case DRINK:
1495 case FLESH:
1496 case INORGANIC:
1497 case CLOSE_CON:
1498 case CLOAK:
1499 case GEM:
1500 case POWER_CRYSTAL:
1501 case POISON:
1502 case BOOK:
1503 case SKILL_TOOL:
1504 return 1;
1505 }
1506
1507 /* Try to track down some stuff that may show up here. Thus, the
1508 * archetype file can be updated, and this function removed.
1509 */
1510#if 0
1511 LOG (llevDebug, "need_identify: %s does not need to be id'd\n", op->name);
1512#endif
1513 return 0;
1514}
1515
1516/* 1531/*
1517 * Supposed to fix face-values as well here, but later. 1532 * Supposed to fix face-values as well here, but later.
1518 */ 1533 */
1519void 1534void
1520identify (object *op) 1535identify (object *op)
1521{ 1536{
1522 SET_FLAG (op, FLAG_IDENTIFIED); 1537 op->set_flag (FLAG_IDENTIFIED);
1523 CLEAR_FLAG (op, FLAG_KNOWN_MAGICAL); 1538 op->clr_flag (FLAG_KNOWN_MAGICAL);
1524 CLEAR_FLAG (op, FLAG_NO_SKILL_IDENT); 1539 op->clr_flag (FLAG_NO_SKILL_IDENT);
1525 1540
1526 /* 1541 /*
1527 * We want autojoining of equal objects: 1542 * We want autojoining of equal objects:
1528 */ 1543 */
1529 if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED)) 1544 if (op->flag [FLAG_CURSED] || op->flag [FLAG_DAMNED])
1530 SET_FLAG (op, FLAG_KNOWN_CURSED); 1545 op->set_flag (FLAG_KNOWN_CURSED);
1531 1546
1532 if (op->type == POTION) 1547 if (op->type == POTION)
1533 { 1548 {
1534 if (op->inv && op->randomitems) 1549 if (op->inv && op->randomitems)
1535 op->title = op->inv->name; 1550 op->title = op->inv->name;

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines