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.82 by root, Tue Apr 6 04:24:29 2010 UTC vs.
Revision 1.88 by root, Wed May 12 20:40:50 2010 UTC

… …
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 */
… …
431ring_desc (const object *op) 489ring_desc (const object *op)
432{ 490{
433 static dynbuf_text buf; buf.clear (); 491 static dynbuf_text buf; buf.clear ();
434 int attr, val, len; 492 int attr, val, len;
435 493
436 if (QUERY_FLAG (op, FLAG_IDENTIFIED)) 494 if (op->flag [FLAG_IDENTIFIED])
437 { 495 {
438 for (attr = 0; attr < NUM_STATS; attr++) 496 for (attr = 0; attr < NUM_STATS; attr++)
439 if ((val = op->stats.stat (attr))) 497 if ((val = op->stats.stat (attr)))
440 buf.printf ("(%s%+d)", short_stat_name[attr], val); 498 buf.printf ("(%s%+d)", short_stat_name[attr], val);
441 499
442 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);
443 if (op->stats.wc) buf.printf ("(wc%+d)", op->stats.wc); 501 if (op->stats.wc) buf.printf ("(wc%+d)", op->stats.wc);
444 if (op->stats.dam) buf.printf ("(dam%+d)", op->stats.dam); 502 if (op->stats.dam) buf.printf ("(dam%+d)", op->stats.dam);
445 if (op->stats.ac) buf.printf ("(ac%+d)", op->stats.ac); 503 if (op->stats.ac) buf.printf ("(ac%+d)", op->stats.ac);
446 504
447 buf << describe_resistance (op, 0); 505 buf << describe_resistance (op, 0);
… …
450 if (op->stats.grace) buf.printf ("(grace%+d)", op->stats.grace); 508 if (op->stats.grace) buf.printf ("(grace%+d)", op->stats.grace);
451 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);
452 if (op->stats.hp) buf.printf ("(regeneration%+d)", op->stats.hp); 510 if (op->stats.hp) buf.printf ("(regeneration%+d)", op->stats.hp);
453 if (op->stats.luck) buf.printf ("(luck%+d)", op->stats.luck); 511 if (op->stats.luck) buf.printf ("(luck%+d)", op->stats.luck);
454 512
455 if (QUERY_FLAG (op, FLAG_LIFESAVE)) buf << "(lifesaving)"; 513 if (op->flag [FLAG_LIFESAVE]) buf << "(lifesaving)";
456 if (QUERY_FLAG (op, FLAG_REFL_SPELL)) buf << "(reflect spells)"; 514 if (op->flag [FLAG_REFL_SPELL]) buf << "(reflect spells)";
457 if (QUERY_FLAG (op, FLAG_REFL_MISSILE)) buf << "(reflect missiles)"; 515 if (op->flag [FLAG_REFL_MISSILE]) buf << "(reflect missiles)";
458 if (QUERY_FLAG (op, FLAG_STEALTH)) buf << "(stealth)"; 516 if (op->flag [FLAG_STEALTH]) buf << "(stealth)";
459 517
460 buf.add_paths ("Attuned" , op->path_attuned); 518 buf.add_paths ("Attuned" , op->path_attuned);
461 buf.add_paths ("Repelled", op->path_repelled); 519 buf.add_paths ("Repelled", op->path_repelled);
462 buf.add_paths ("Denied" , op->path_denied); 520 buf.add_paths ("Denied" , op->path_denied);
463 521
… …
489 547
490 static dynbuf_text buf; buf.clear (); 548 static dynbuf_text buf; buf.clear ();
491 549
492 buf << (op->nrof <= 1 ? op->name : op->name_pl); 550 buf << (op->nrof <= 1 ? op->name : op->name_pl);
493 551
494 if (op->title && QUERY_FLAG (op, FLAG_IDENTIFIED)) 552 if (op->title && op->flag [FLAG_IDENTIFIED])
495 buf << ' ' << op->title; 553 buf << ' ' << op->title;
496 554
497 switch (op->type) 555 switch (op->type)
498 { 556 {
499 case SPELLBOOK: 557 case SPELLBOOK:
500 case SCROLL: 558 case SCROLL:
501 case WAND: 559 case WAND:
502 case ROD: 560 case ROD:
503 if (QUERY_FLAG (op, FLAG_IDENTIFIED) || QUERY_FLAG (op, FLAG_BEEN_APPLIED)) 561 if (op->flag [FLAG_IDENTIFIED] || op->flag [FLAG_BEEN_APPLIED])
504 { 562 {
505 if (!op->title) 563 if (!op->title)
506 buf << " of " << (op->inv ? &op->inv->name : "bug, please report"); 564 buf << " of " << (op->inv ? &op->inv->name : "bug, please report");
507 565
508 if (op->type != SPELLBOOK) 566 if (op->type != SPELLBOOK)
… …
547 buf << " " << s; 605 buf << " " << s;
548 } 606 }
549 break; 607 break;
550 608
551 default: 609 default:
552 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]))
553 buf.printf (" %+d", op->magic); 613 buf.printf (" %+d", op->magic);
554 } 614 }
555 615
556 return buf; 616 return buf;
557} 617}
… …
588 buf << op->material->description << ' '; 648 buf << op->material->description << ' ';
589#endif 649#endif
590 650
591 buf << query_short_name (op); 651 buf << query_short_name (op);
592 652
593 if (QUERY_FLAG (op, FLAG_INV_LOCKED)) 653 if (op->flag [FLAG_INV_LOCKED])
594 buf << " *"; 654 buf << " *";
595 if (op->is_open_container ()) 655 if (op->is_open_container ())
596 buf << " (open)"; 656 buf << " (open)";
597 657
598 if (QUERY_FLAG (op, FLAG_KNOWN_CURSED)) 658 if (op->flag [FLAG_KNOWN_CURSED])
599 { 659 {
600 if (QUERY_FLAG (op, FLAG_DAMNED)) 660 if (op->flag [FLAG_DAMNED])
601 buf << " (damned)"; 661 buf << " (damned)";
602 else if (QUERY_FLAG (op, FLAG_CURSED)) 662 else if (op->flag [FLAG_CURSED])
603 buf << " (cursed)"; 663 buf << " (cursed)";
604 } 664 }
605 665
606 /* 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),
607 * and it isn't identified, print out the fact that 667 * and it isn't identified, print out the fact that
… …
610 * 670 *
611 * 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
612 * 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
613 * abilities, especially for artifact items. 673 * abilities, especially for artifact items.
614 */ 674 */
615 if (QUERY_FLAG (op, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (op, FLAG_IDENTIFIED)) 675 if (op->flag [FLAG_KNOWN_MAGICAL] && !op->flag [FLAG_IDENTIFIED])
616 buf << " (magic)"; 676 buf << " (magic)";
617 677
618#if 0 678#if 0
619 /* 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
620 * be returned in the name. 680 * be returned in the name.
… …
622 if (op->item_power) 682 if (op->item_power)
623 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);
624 684
625#endif 685#endif
626 686
627 if (QUERY_FLAG (op, FLAG_APPLIED)) 687 if (op->flag [FLAG_APPLIED])
628 { 688 {
629 switch (op->type) 689 switch (op->type)
630 { 690 {
631 case BOW: 691 case BOW:
632 case WAND: 692 case WAND:
… …
675 else if (op->stats.food <= 0) 735 else if (op->stats.food <= 0)
676 buf << " (burned out)"; 736 buf << " (burned out)";
677 break; 737 break;
678 } 738 }
679 739
680 if (QUERY_FLAG (op, FLAG_UNPAID)) 740 if (op->flag [FLAG_UNPAID])
681 buf << " (unpaid)"; 741 buf << " (unpaid)";
682 742
683 return buf; 743 return buf;
684} 744}
685 745
… …
714 buf << op->material->description << ' '; 774 buf << op->material->description << ' ';
715#endif 775#endif
716 776
717 buf << (plural ? op->name_pl : op->name); 777 buf << (plural ? op->name_pl : op->name);
718 778
719 if (op->title && QUERY_FLAG (op, FLAG_IDENTIFIED)) 779 if (op->title && op->flag [FLAG_IDENTIFIED])
720 buf << ' ' << op->title; 780 buf << ' ' << op->title;
721 781
722 switch (op->type) 782 switch (op->type)
723 { 783 {
724 case SPELLBOOK: 784 case SPELLBOOK:
725 case SCROLL: 785 case SCROLL:
726 case WAND: 786 case WAND:
727 case ROD: 787 case ROD:
728 if (QUERY_FLAG (op, FLAG_IDENTIFIED) || QUERY_FLAG (op, FLAG_BEEN_APPLIED)) 788 if (op->flag [FLAG_IDENTIFIED] || op->flag [FLAG_BEEN_APPLIED])
729 { 789 {
730 if (!op->title) 790 if (!op->title)
731 buf << " of " << (op->inv ? &op->inv->name : "bug, please report"); 791 buf << " of " << (op->inv ? &op->inv->name : "bug, please report");
732 792
733 if (op->type != SPELLBOOK) 793 if (op->type != SPELLBOOK)
… …
756 else if (!EXIT_PATH (op)) 816 else if (!EXIT_PATH (op))
757 buf << " (closed)"; 817 buf << " (closed)";
758 break; 818 break;
759 819
760 default: 820 default:
761 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]))
762 buf.printf (" %+d", op->magic); 824 buf.printf (" %+d", op->magic);
763 } 825 }
764 826
765 return buf; 827 return buf;
766} 828}
… …
809 default: 871 default:
810 buf << "(lightning fast movement)"; 872 buf << "(lightning fast movement)";
811 break; 873 break;
812 } 874 }
813 875
814 if (QUERY_FLAG (op, FLAG_UNDEAD)) buf << "(undead)"; 876 if (op->flag [FLAG_UNDEAD]) buf << "(undead)";
815 if (QUERY_FLAG (op, FLAG_SEE_INVISIBLE)) buf << "(see invisible)"; 877 if (op->flag [FLAG_SEE_INVISIBLE]) buf << "(see invisible)";
816 if (QUERY_FLAG (op, FLAG_USE_WEAPON)) buf << "(wield weapon)"; 878 if (op->flag [FLAG_USE_WEAPON]) buf << "(wield weapon)";
817 if (QUERY_FLAG (op, FLAG_USE_BOW)) buf << "(archer)"; 879 if (op->flag [FLAG_USE_BOW]) buf << "(archer)";
818 if (QUERY_FLAG (op, FLAG_USE_ARMOUR)) buf << "(wear armour)"; 880 if (op->flag [FLAG_USE_ARMOUR]) buf << "(wear armour)";
819 if (QUERY_FLAG (op, FLAG_USE_RING)) buf << "(wear ring)"; 881 if (op->flag [FLAG_USE_RING]) buf << "(wear ring)";
820 if (QUERY_FLAG (op, FLAG_USE_SCROLL)) buf << "(read scroll)"; 882 if (op->flag [FLAG_USE_SCROLL]) buf << "(read scroll)";
821 if (QUERY_FLAG (op, FLAG_USE_RANGE)) buf << "(fires wand/rod/horn)"; 883 if (op->flag [FLAG_USE_RANGE]) buf << "(fires wand/rod/horn)";
822 if (QUERY_FLAG (op, FLAG_CAN_USE_SKILL)) buf << "(skill user)"; 884 if (op->flag [FLAG_CAN_USE_SKILL]) buf << "(skill user)";
823 if (QUERY_FLAG (op, FLAG_CAST_SPELL)) buf << "(spellcaster)"; 885 if (op->flag [FLAG_CAST_SPELL]) buf << "(spellcaster)";
824 if (QUERY_FLAG (op, FLAG_FRIENDLY)) buf << "(friendly)"; 886 if (op->flag [FLAG_FRIENDLY]) buf << "(friendly)";
825 if (QUERY_FLAG (op, FLAG_UNAGGRESSIVE)) buf << "(unaggressive)"; 887 if (op->flag [FLAG_UNAGGRESSIVE]) buf << "(unaggressive)";
826 if (QUERY_FLAG (op, FLAG_HITBACK)) buf << "(hitback)"; 888 if (op->flag [FLAG_HITBACK]) buf << "(hitback)";
827 if (QUERY_FLAG (op, FLAG_STEALTH)) buf << "(stealthy)"; 889 if (op->flag [FLAG_STEALTH]) buf << "(stealthy)";
828 890
829 if (op->randomitems) 891 if (op->randomitems)
830 { 892 {
831 bool first = 1; 893 bool first = 1;
832 894
… …
914 * item (eg, debug dump or the like) 976 * item (eg, debug dump or the like)
915 */ 977 */
916const char * 978const char *
917describe_item (const object *op, object *owner) 979describe_item (const object *op, object *owner)
918{ 980{
919 if (QUERY_FLAG (op, FLAG_MONSTER) || op->type == PLAYER) 981 if (op->flag [FLAG_MONSTER] || op->type == PLAYER)
920 return describe_monster (op); 982 return describe_monster (op);
921 983
922 static dynbuf_text buf; buf.clear (); 984 static dynbuf_text buf; buf.clear ();
923 int identified, i; 985 int identified, i;
924 986
925 /* 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.
926 * also makes the code easier to read. 988 * also makes the code easier to read.
927 */ 989 */
928 identified = !need_identify (op) || QUERY_FLAG (op, FLAG_IDENTIFIED); 990 identified = !op->need_identify () || op->flag [FLAG_IDENTIFIED];
929 if (!identified) 991 if (!identified)
930 buf << "(unidentified)"; 992 buf << "(unidentified)";
931 993
932 switch (op->type) 994 switch (op->type)
933 { 995 {
… …
1003 break; 1065 break;
1004 1066
1005 case FOOD: 1067 case FOOD:
1006 case FLESH: 1068 case FLESH:
1007 case DRINK: 1069 case DRINK:
1008 if (identified || QUERY_FLAG (op, FLAG_BEEN_APPLIED)) 1070 if (identified || op->flag [FLAG_BEEN_APPLIED])
1009 { 1071 {
1010 buf.printf ("(food+%d)", op->stats.food); 1072 buf.printf ("(food+%d)", op->stats.food);
1011 1073
1012 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))
1013 buf.printf ("(%s metabolism)", change_resist_msg[op->last_eat]); 1075 buf.printf ("(%s metabolism)", change_resist_msg[op->last_eat]);
1014 1076
1015 if (!QUERY_FLAG (op, FLAG_CURSED)) 1077 if (!op->flag [FLAG_CURSED])
1016 { 1078 {
1017 if (op->stats.hp) buf << "(heals)"; 1079 if (op->stats.hp) buf << "(heals)";
1018 if (op->stats.sp) buf << "(spellpoint regen)"; 1080 if (op->stats.sp) buf << "(spellpoint regen)";
1019 } 1081 }
1020 else 1082 else
… …
1041 } 1103 }
1042 1104
1043 /* Down here, we more further describe equipment type items. 1105 /* Down here, we more further describe equipment type items.
1044 * only describe them if they have been identified or the like. 1106 * only describe them if they have been identified or the like.
1045 */ 1107 */
1046 if (identified || QUERY_FLAG (op, FLAG_BEEN_APPLIED)) 1108 if (identified || op->flag [FLAG_BEEN_APPLIED])
1047 { 1109 {
1048 int attr, val; 1110 int attr, val;
1049 1111
1050 for (attr = 0; attr < NUM_STATS; attr++) 1112 for (attr = 0; attr < NUM_STATS; attr++)
1051 if ((val = op->stats.stat (attr))) 1113 if ((val = op->stats.stat (attr)))
… …
1082 1144
1083 default: 1145 default:
1084 break; 1146 break;
1085 } 1147 }
1086 1148
1087 if (QUERY_FLAG (op, FLAG_XRAYS)) buf << "(xray-vision)"; 1149 if (op->flag [FLAG_XRAYS]) buf << "(xray-vision)";
1088 if (QUERY_FLAG (op, FLAG_SEE_IN_DARK)) buf << "(infravision)"; 1150 if (op->flag [FLAG_SEE_IN_DARK]) buf << "(infravision)";
1089 1151
1090 /* levitate was what is was before, so we'll keep it */ 1152 /* levitate was what is was before, so we'll keep it */
1091 if (op->move_type & MOVE_FLY_LOW) buf << "(levitate)"; 1153 if (op->move_type & MOVE_FLY_LOW) buf << "(levitate)";
1092 if (op->move_type & MOVE_FLY_HIGH) buf << "(fly)"; 1154 if (op->move_type & MOVE_FLY_HIGH) buf << "(fly)";
1093 if (op->move_type & MOVE_SWIM) buf << "(swim)"; 1155 if (op->move_type & MOVE_SWIM) buf << "(swim)";
… …
1155 } 1217 }
1156 1218
1157 if (op->stats.luck) 1219 if (op->stats.luck)
1158 buf.printf ("(luck%+d)", op->stats.luck); 1220 buf.printf ("(luck%+d)", op->stats.luck);
1159 1221
1160 if (QUERY_FLAG (op, FLAG_LIFESAVE)) buf << "(lifesaving)"; 1222 if (op->flag [FLAG_LIFESAVE]) buf << "(lifesaving)";
1161 if (QUERY_FLAG (op, FLAG_REFL_SPELL)) buf << "(reflect spells)"; 1223 if (op->flag [FLAG_REFL_SPELL]) buf << "(reflect spells)";
1162 if (QUERY_FLAG (op, FLAG_REFL_MISSILE)) buf << "(reflect missiles)"; 1224 if (op->flag [FLAG_REFL_MISSILE]) buf << "(reflect missiles)";
1163 if (QUERY_FLAG (op, FLAG_STEALTH)) buf << "(stealth)"; 1225 if (op->flag [FLAG_STEALTH]) buf << "(stealth)";
1164 1226
1165 if (op->slaying && op->type != FOOD) 1227 if (op->slaying && op->type != FOOD)
1166 buf.printf ("(slay %s)", &op->slaying); 1228 buf.printf ("(slay %s)", &op->slaying);
1167 1229
1168 if (op->type == SKILL_TOOL && op->skill) 1230 if (op->type == SKILL_TOOL && op->skill)
… …
1291 */ 1353 */
1292 if (msg) 1354 if (msg)
1293 { 1355 {
1294 if (type != EXIT && type != BOOK && type != CORPSE && !move_on && !has_dialogue ()) 1356 if (type != EXIT && type != BOOK && type != CORPSE && !move_on && !has_dialogue ())
1295 { 1357 {
1296 buf << '\r'; 1358 if (!need_identify ())
1297 1359 buf << '\r' << msg << '\n';
1298 /* This is just a hack so when identifying the items, we print 1360 else if (flag [FLAG_IDENTIFIED])
1299 * out the extra message
1300 */
1301 if (need_identify (this) && flag [FLAG_IDENTIFIED])
1302 buf << "The object has a story:\r"; 1361 buf << '\r' << "The object has a story:\r" << msg;
1303
1304 buf << msg << '\n';
1305 } 1362 }
1306 } 1363 }
1307 else if (inv && inv->type == SPELL && flag [FLAG_IDENTIFIED] 1364 else if (inv
1365 && inv->msg
1366 && inv->type == SPELL
1367 && flag [FLAG_IDENTIFIED]
1308 && (type == SPELLBOOK || type == ROD || type == WAND 1368 && (type == SPELLBOOK || type == ROD || type == WAND
1309 || type == ROD || type == POTION || type == SCROLL)) 1369 || type == ROD || type == POTION || type == SCROLL))
1310 // 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,
1311 // unless the object has a custom message handled above. 1371 // unless the object has a custom message handled above.
1312 buf << '\r' << inv->msg << '\n'; 1372 buf << '\r' << inv->msg << '\n';
… …
1378object::query_inventory (object *who, const char *indent) 1438object::query_inventory (object *who, const char *indent)
1379{ 1439{
1380 static dynbuf_text buf; buf.clear (); 1440 static dynbuf_text buf; buf.clear ();
1381 1441
1382 for (object *tmp = inv; tmp; tmp = tmp->below) 1442 for (object *tmp = inv; tmp; tmp = tmp->below)
1383 if (who && QUERY_FLAG (who, FLAG_WIZ)) 1443 if (who && who->flag [FLAG_WIZ])
1384 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 ());
1385 else if (!tmp->invisible && (type == CONTAINER || QUERY_FLAG (tmp, FLAG_APPLIED))) 1445 else if (!tmp->invisible && (type == CONTAINER || tmp->flag [FLAG_APPLIED]))
1386 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 ());
1387 1447
1388 if (buf.size ()) 1448 if (buf.size ())
1389 buf.printf ("%s(total weight: %s)\n", indent, query_weight ()); 1449 buf.printf ("%s(total weight: %s)\n", indent, query_weight ());
1390 else 1450 else
… …
1403is_magical (const object *op) 1463is_magical (const object *op)
1404{ 1464{
1405 int i; 1465 int i;
1406 1466
1407 /* living creatures are considered non magical */ 1467 /* living creatures are considered non magical */
1408 if (QUERY_FLAG (op, FLAG_ALIVE)) 1468 if (op->flag [FLAG_ALIVE])
1409 return 0; 1469 return 0;
1410 1470
1411 /* 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 */
1412 if (op->title != NULL) 1472 if (op->title != NULL)
1413 return 1; 1473 return 1;
… …
1419 (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))
1420 return 1; 1480 return 1;
1421 1481
1422 /* 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 */
1423 /* Presume any boots that hvae a move_type are special. */ 1483 /* Presume any boots that hvae a move_type are special. */
1424 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)))
1425 return 1; 1485 return 1;
1426 1486
1427 /* Take care of amulet/shield that reflects spells/missiles */ 1487 /* Take care of amulet/shield that reflects spells/missiles */
1428 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]))
1429 return 1; 1489 return 1;
1430 1490
1431 /* Take care of helmet of xrays */ 1491 /* Take care of helmet of xrays */
1432 if (op->type == HELMET && QUERY_FLAG (op, FLAG_XRAYS)) 1492 if (op->type == HELMET && op->flag [FLAG_XRAYS])
1433 return 1; 1493 return 1;
1434 1494
1435 /* Potions & rods are always magical. Wands/staves are also magical, 1495 /* Potions & rods are always magical. Wands/staves are also magical,
1436 * assuming they still have any charges left. 1496 * assuming they still have any charges left.
1437 */ 1497 */
… …
1466 * be non magical. 1526 * be non magical.
1467 */ 1527 */
1468 return 0; 1528 return 0;
1469} 1529}
1470 1530
1471/* need_identify returns true if the item should be identified. This
1472 * function really should not exist - by default, any item not identified
1473 * should need it.
1474 */
1475
1476int
1477need_identify (const object *op)
1478{
1479 switch (op->type)
1480 {
1481 case RING:
1482 case WAND:
1483 case ROD:
1484 case HORN:
1485 case SCROLL:
1486 case SKILL:
1487 case SKILLSCROLL:
1488 case SPELLBOOK:
1489 case FOOD:
1490 case POTION:
1491 case BOW:
1492 case ARROW:
1493 case WEAPON:
1494 case ARMOUR:
1495 case SHIELD:
1496 case HELMET:
1497 case AMULET:
1498 case BOOTS:
1499 case GLOVES:
1500 case BRACERS:
1501 case GIRDLE:
1502 case CONTAINER:
1503 case DRINK:
1504 case FLESH:
1505 case INORGANIC:
1506 case CLOSE_CON:
1507 case CLOAK:
1508 case GEM:
1509 case POWER_CRYSTAL:
1510 case POISON:
1511 case BOOK:
1512 case SKILL_TOOL:
1513 return 1;
1514 }
1515
1516 /* Try to track down some stuff that may show up here. Thus, the
1517 * archetype file can be updated, and this function removed.
1518 */
1519#if 0
1520 LOG (llevDebug, "need_identify: %s does not need to be id'd\n", op->name);
1521#endif
1522 return 0;
1523}
1524
1525/* 1531/*
1526 * Supposed to fix face-values as well here, but later. 1532 * Supposed to fix face-values as well here, but later.
1527 */ 1533 */
1528void 1534void
1529identify (object *op) 1535identify (object *op)
1530{ 1536{
1531 SET_FLAG (op, FLAG_IDENTIFIED); 1537 op->set_flag (FLAG_IDENTIFIED);
1532 CLEAR_FLAG (op, FLAG_KNOWN_MAGICAL); 1538 op->clr_flag (FLAG_KNOWN_MAGICAL);
1533 CLEAR_FLAG (op, FLAG_NO_SKILL_IDENT); 1539 op->clr_flag (FLAG_NO_SKILL_IDENT);
1534 1540
1535 /* 1541 /*
1536 * We want autojoining of equal objects: 1542 * We want autojoining of equal objects:
1537 */ 1543 */
1538 if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED)) 1544 if (op->flag [FLAG_CURSED] || op->flag [FLAG_DAMNED])
1539 SET_FLAG (op, FLAG_KNOWN_CURSED); 1545 op->set_flag (FLAG_KNOWN_CURSED);
1540 1546
1541 if (op->type == POTION) 1547 if (op->type == POTION)
1542 { 1548 {
1543 if (op->inv && op->randomitems) 1549 if (op->inv && op->randomitems)
1544 op->title = op->inv->name; 1550 op->title = op->inv->name;

Diff Legend

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