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.86 by root, Fri Apr 30 20:43:17 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
… …
431ring_desc (const object *op) 477ring_desc (const object *op)
432{ 478{
433 static dynbuf_text buf; buf.clear (); 479 static dynbuf_text buf; buf.clear ();
434 int attr, val, len; 480 int attr, val, len;
435 481
436 if (QUERY_FLAG (op, FLAG_IDENTIFIED)) 482 if (op->flag [FLAG_IDENTIFIED])
437 { 483 {
438 for (attr = 0; attr < NUM_STATS; attr++) 484 for (attr = 0; attr < NUM_STATS; attr++)
439 if ((val = op->stats.stat (attr))) 485 if ((val = op->stats.stat (attr)))
440 buf.printf ("(%s%+d)", short_stat_name[attr], val); 486 buf.printf ("(%s%+d)", short_stat_name[attr], val);
441 487
… …
450 if (op->stats.grace) buf.printf ("(grace%+d)", op->stats.grace); 496 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); 497 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); 498 if (op->stats.hp) buf.printf ("(regeneration%+d)", op->stats.hp);
453 if (op->stats.luck) buf.printf ("(luck%+d)", op->stats.luck); 499 if (op->stats.luck) buf.printf ("(luck%+d)", op->stats.luck);
454 500
455 if (QUERY_FLAG (op, FLAG_LIFESAVE)) buf << "(lifesaving)"; 501 if (op->flag [FLAG_LIFESAVE]) buf << "(lifesaving)";
456 if (QUERY_FLAG (op, FLAG_REFL_SPELL)) buf << "(reflect spells)"; 502 if (op->flag [FLAG_REFL_SPELL]) buf << "(reflect spells)";
457 if (QUERY_FLAG (op, FLAG_REFL_MISSILE)) buf << "(reflect missiles)"; 503 if (op->flag [FLAG_REFL_MISSILE]) buf << "(reflect missiles)";
458 if (QUERY_FLAG (op, FLAG_STEALTH)) buf << "(stealth)"; 504 if (op->flag [FLAG_STEALTH]) buf << "(stealth)";
459 505
460 buf.add_paths ("Attuned" , op->path_attuned); 506 buf.add_paths ("Attuned" , op->path_attuned);
461 buf.add_paths ("Repelled", op->path_repelled); 507 buf.add_paths ("Repelled", op->path_repelled);
462 buf.add_paths ("Denied" , op->path_denied); 508 buf.add_paths ("Denied" , op->path_denied);
463 509
… …
489 535
490 static dynbuf_text buf; buf.clear (); 536 static dynbuf_text buf; buf.clear ();
491 537
492 buf << (op->nrof <= 1 ? op->name : op->name_pl); 538 buf << (op->nrof <= 1 ? op->name : op->name_pl);
493 539
494 if (op->title && QUERY_FLAG (op, FLAG_IDENTIFIED)) 540 if (op->title && op->flag [FLAG_IDENTIFIED])
495 buf << ' ' << op->title; 541 buf << ' ' << op->title;
496 542
497 switch (op->type) 543 switch (op->type)
498 { 544 {
499 case SPELLBOOK: 545 case SPELLBOOK:
500 case SCROLL: 546 case SCROLL:
501 case WAND: 547 case WAND:
502 case ROD: 548 case ROD:
503 if (QUERY_FLAG (op, FLAG_IDENTIFIED) || QUERY_FLAG (op, FLAG_BEEN_APPLIED)) 549 if (op->flag [FLAG_IDENTIFIED] || op->flag [FLAG_BEEN_APPLIED])
504 { 550 {
505 if (!op->title) 551 if (!op->title)
506 buf << " of " << (op->inv ? &op->inv->name : "bug, please report"); 552 buf << " of " << (op->inv ? &op->inv->name : "bug, please report");
507 553
508 if (op->type != SPELLBOOK) 554 if (op->type != SPELLBOOK)
… …
547 buf << " " << s; 593 buf << " " << s;
548 } 594 }
549 break; 595 break;
550 596
551 default: 597 default:
552 if (op->magic && ((QUERY_FLAG (op, FLAG_BEEN_APPLIED) && need_identify (op)) || QUERY_FLAG (op, FLAG_IDENTIFIED))) 598 if (op->magic
599 && ((op->flag [FLAG_BEEN_APPLIED] && op->need_identify ())
600 || op->flag [FLAG_IDENTIFIED]))
553 buf.printf (" %+d", op->magic); 601 buf.printf (" %+d", op->magic);
554 } 602 }
555 603
556 return buf; 604 return buf;
557} 605}
… …
588 buf << op->material->description << ' '; 636 buf << op->material->description << ' ';
589#endif 637#endif
590 638
591 buf << query_short_name (op); 639 buf << query_short_name (op);
592 640
593 if (QUERY_FLAG (op, FLAG_INV_LOCKED)) 641 if (op->flag [FLAG_INV_LOCKED])
594 buf << " *"; 642 buf << " *";
595 if (op->is_open_container ()) 643 if (op->is_open_container ())
596 buf << " (open)"; 644 buf << " (open)";
597 645
598 if (QUERY_FLAG (op, FLAG_KNOWN_CURSED)) 646 if (op->flag [FLAG_KNOWN_CURSED])
599 { 647 {
600 if (QUERY_FLAG (op, FLAG_DAMNED)) 648 if (op->flag [FLAG_DAMNED])
601 buf << " (damned)"; 649 buf << " (damned)";
602 else if (QUERY_FLAG (op, FLAG_CURSED)) 650 else if (op->flag [FLAG_CURSED])
603 buf << " (cursed)"; 651 buf << " (cursed)";
604 } 652 }
605 653
606 /* Basically, if the object is known magical (detect magic spell on it), 654 /* Basically, if the object is known magical (detect magic spell on it),
607 * and it isn't identified, print out the fact that 655 * and it isn't identified, print out the fact that
… …
610 * 658 *
611 * Changed in V 0.91.4 - still print that the object is magical even 659 * 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 660 * if it has been applied. Equipping an item does not tell full
613 * abilities, especially for artifact items. 661 * abilities, especially for artifact items.
614 */ 662 */
615 if (QUERY_FLAG (op, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (op, FLAG_IDENTIFIED)) 663 if (op->flag [FLAG_KNOWN_MAGICAL] && !op->flag [FLAG_IDENTIFIED])
616 buf << " (magic)"; 664 buf << " (magic)";
617 665
618#if 0 666#if 0
619 /* item_power will be returned in describe_item - it shouldn't really 667 /* item_power will be returned in describe_item - it shouldn't really
620 * be returned in the name. 668 * be returned in the name.
… …
622 if (op->item_power) 670 if (op->item_power)
623 sprintf (buf[use_buf] + strlen (buf[use_buf]), "(item_power %+d)", op->item_power); 671 sprintf (buf[use_buf] + strlen (buf[use_buf]), "(item_power %+d)", op->item_power);
624 672
625#endif 673#endif
626 674
627 if (QUERY_FLAG (op, FLAG_APPLIED)) 675 if (op->flag [FLAG_APPLIED])
628 { 676 {
629 switch (op->type) 677 switch (op->type)
630 { 678 {
631 case BOW: 679 case BOW:
632 case WAND: 680 case WAND:
… …
675 else if (op->stats.food <= 0) 723 else if (op->stats.food <= 0)
676 buf << " (burned out)"; 724 buf << " (burned out)";
677 break; 725 break;
678 } 726 }
679 727
680 if (QUERY_FLAG (op, FLAG_UNPAID)) 728 if (op->flag [FLAG_UNPAID])
681 buf << " (unpaid)"; 729 buf << " (unpaid)";
682 730
683 return buf; 731 return buf;
684} 732}
685 733
… …
714 buf << op->material->description << ' '; 762 buf << op->material->description << ' ';
715#endif 763#endif
716 764
717 buf << (plural ? op->name_pl : op->name); 765 buf << (plural ? op->name_pl : op->name);
718 766
719 if (op->title && QUERY_FLAG (op, FLAG_IDENTIFIED)) 767 if (op->title && op->flag [FLAG_IDENTIFIED])
720 buf << ' ' << op->title; 768 buf << ' ' << op->title;
721 769
722 switch (op->type) 770 switch (op->type)
723 { 771 {
724 case SPELLBOOK: 772 case SPELLBOOK:
725 case SCROLL: 773 case SCROLL:
726 case WAND: 774 case WAND:
727 case ROD: 775 case ROD:
728 if (QUERY_FLAG (op, FLAG_IDENTIFIED) || QUERY_FLAG (op, FLAG_BEEN_APPLIED)) 776 if (op->flag [FLAG_IDENTIFIED] || op->flag [FLAG_BEEN_APPLIED])
729 { 777 {
730 if (!op->title) 778 if (!op->title)
731 buf << " of " << (op->inv ? &op->inv->name : "bug, please report"); 779 buf << " of " << (op->inv ? &op->inv->name : "bug, please report");
732 780
733 if (op->type != SPELLBOOK) 781 if (op->type != SPELLBOOK)
… …
756 else if (!EXIT_PATH (op)) 804 else if (!EXIT_PATH (op))
757 buf << " (closed)"; 805 buf << " (closed)";
758 break; 806 break;
759 807
760 default: 808 default:
761 if (op->magic && ((QUERY_FLAG (op, FLAG_BEEN_APPLIED) && need_identify (op)) || QUERY_FLAG (op, FLAG_IDENTIFIED))) 809 if (op->magic
810 && ((op->flag [FLAG_BEEN_APPLIED] && op->need_identify ())
811 || op->flag [FLAG_IDENTIFIED]))
762 buf.printf (" %+d", op->magic); 812 buf.printf (" %+d", op->magic);
763 } 813 }
764 814
765 return buf; 815 return buf;
766} 816}
… …
809 default: 859 default:
810 buf << "(lightning fast movement)"; 860 buf << "(lightning fast movement)";
811 break; 861 break;
812 } 862 }
813 863
814 if (QUERY_FLAG (op, FLAG_UNDEAD)) buf << "(undead)"; 864 if (op->flag [FLAG_UNDEAD]) buf << "(undead)";
815 if (QUERY_FLAG (op, FLAG_SEE_INVISIBLE)) buf << "(see invisible)"; 865 if (op->flag [FLAG_SEE_INVISIBLE]) buf << "(see invisible)";
816 if (QUERY_FLAG (op, FLAG_USE_WEAPON)) buf << "(wield weapon)"; 866 if (op->flag [FLAG_USE_WEAPON]) buf << "(wield weapon)";
817 if (QUERY_FLAG (op, FLAG_USE_BOW)) buf << "(archer)"; 867 if (op->flag [FLAG_USE_BOW]) buf << "(archer)";
818 if (QUERY_FLAG (op, FLAG_USE_ARMOUR)) buf << "(wear armour)"; 868 if (op->flag [FLAG_USE_ARMOUR]) buf << "(wear armour)";
819 if (QUERY_FLAG (op, FLAG_USE_RING)) buf << "(wear ring)"; 869 if (op->flag [FLAG_USE_RING]) buf << "(wear ring)";
820 if (QUERY_FLAG (op, FLAG_USE_SCROLL)) buf << "(read scroll)"; 870 if (op->flag [FLAG_USE_SCROLL]) buf << "(read scroll)";
821 if (QUERY_FLAG (op, FLAG_USE_RANGE)) buf << "(fires wand/rod/horn)"; 871 if (op->flag [FLAG_USE_RANGE]) buf << "(fires wand/rod/horn)";
822 if (QUERY_FLAG (op, FLAG_CAN_USE_SKILL)) buf << "(skill user)"; 872 if (op->flag [FLAG_CAN_USE_SKILL]) buf << "(skill user)";
823 if (QUERY_FLAG (op, FLAG_CAST_SPELL)) buf << "(spellcaster)"; 873 if (op->flag [FLAG_CAST_SPELL]) buf << "(spellcaster)";
824 if (QUERY_FLAG (op, FLAG_FRIENDLY)) buf << "(friendly)"; 874 if (op->flag [FLAG_FRIENDLY]) buf << "(friendly)";
825 if (QUERY_FLAG (op, FLAG_UNAGGRESSIVE)) buf << "(unaggressive)"; 875 if (op->flag [FLAG_UNAGGRESSIVE]) buf << "(unaggressive)";
826 if (QUERY_FLAG (op, FLAG_HITBACK)) buf << "(hitback)"; 876 if (op->flag [FLAG_HITBACK]) buf << "(hitback)";
827 if (QUERY_FLAG (op, FLAG_STEALTH)) buf << "(stealthy)"; 877 if (op->flag [FLAG_STEALTH]) buf << "(stealthy)";
828 878
829 if (op->randomitems) 879 if (op->randomitems)
830 { 880 {
831 bool first = 1; 881 bool first = 1;
832 882
… …
914 * item (eg, debug dump or the like) 964 * item (eg, debug dump or the like)
915 */ 965 */
916const char * 966const char *
917describe_item (const object *op, object *owner) 967describe_item (const object *op, object *owner)
918{ 968{
919 if (QUERY_FLAG (op, FLAG_MONSTER) || op->type == PLAYER) 969 if (op->flag [FLAG_MONSTER] || op->type == PLAYER)
920 return describe_monster (op); 970 return describe_monster (op);
921 971
922 static dynbuf_text buf; buf.clear (); 972 static dynbuf_text buf; buf.clear ();
923 int identified, i; 973 int identified, i;
924 974
925 /* figure this out once, instead of making multiple calls to need_identify. 975 /* figure this out once, instead of making multiple calls to need_identify.
926 * also makes the code easier to read. 976 * also makes the code easier to read.
927 */ 977 */
928 identified = !need_identify (op) || QUERY_FLAG (op, FLAG_IDENTIFIED); 978 identified = !op->need_identify () || op->flag [FLAG_IDENTIFIED];
929 if (!identified) 979 if (!identified)
930 buf << "(unidentified)"; 980 buf << "(unidentified)";
931 981
932 switch (op->type) 982 switch (op->type)
933 { 983 {
… …
1003 break; 1053 break;
1004 1054
1005 case FOOD: 1055 case FOOD:
1006 case FLESH: 1056 case FLESH:
1007 case DRINK: 1057 case DRINK:
1008 if (identified || QUERY_FLAG (op, FLAG_BEEN_APPLIED)) 1058 if (identified || op->flag [FLAG_BEEN_APPLIED])
1009 { 1059 {
1010 buf.printf ("(food+%d)", op->stats.food); 1060 buf.printf ("(food+%d)", op->stats.food);
1011 1061
1012 if (op->type == FLESH && op->last_eat > 0 && atnr_is_dragon_enabled (op->last_eat)) 1062 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]); 1063 buf.printf ("(%s metabolism)", change_resist_msg[op->last_eat]);
1014 1064
1015 if (!QUERY_FLAG (op, FLAG_CURSED)) 1065 if (!op->flag [FLAG_CURSED])
1016 { 1066 {
1017 if (op->stats.hp) buf << "(heals)"; 1067 if (op->stats.hp) buf << "(heals)";
1018 if (op->stats.sp) buf << "(spellpoint regen)"; 1068 if (op->stats.sp) buf << "(spellpoint regen)";
1019 } 1069 }
1020 else 1070 else
… …
1041 } 1091 }
1042 1092
1043 /* Down here, we more further describe equipment type items. 1093 /* Down here, we more further describe equipment type items.
1044 * only describe them if they have been identified or the like. 1094 * only describe them if they have been identified or the like.
1045 */ 1095 */
1046 if (identified || QUERY_FLAG (op, FLAG_BEEN_APPLIED)) 1096 if (identified || op->flag [FLAG_BEEN_APPLIED])
1047 { 1097 {
1048 int attr, val; 1098 int attr, val;
1049 1099
1050 for (attr = 0; attr < NUM_STATS; attr++) 1100 for (attr = 0; attr < NUM_STATS; attr++)
1051 if ((val = op->stats.stat (attr))) 1101 if ((val = op->stats.stat (attr)))
… …
1082 1132
1083 default: 1133 default:
1084 break; 1134 break;
1085 } 1135 }
1086 1136
1087 if (QUERY_FLAG (op, FLAG_XRAYS)) buf << "(xray-vision)"; 1137 if (op->flag [FLAG_XRAYS]) buf << "(xray-vision)";
1088 if (QUERY_FLAG (op, FLAG_SEE_IN_DARK)) buf << "(infravision)"; 1138 if (op->flag [FLAG_SEE_IN_DARK]) buf << "(infravision)";
1089 1139
1090 /* levitate was what is was before, so we'll keep it */ 1140 /* levitate was what is was before, so we'll keep it */
1091 if (op->move_type & MOVE_FLY_LOW) buf << "(levitate)"; 1141 if (op->move_type & MOVE_FLY_LOW) buf << "(levitate)";
1092 if (op->move_type & MOVE_FLY_HIGH) buf << "(fly)"; 1142 if (op->move_type & MOVE_FLY_HIGH) buf << "(fly)";
1093 if (op->move_type & MOVE_SWIM) buf << "(swim)"; 1143 if (op->move_type & MOVE_SWIM) buf << "(swim)";
… …
1155 } 1205 }
1156 1206
1157 if (op->stats.luck) 1207 if (op->stats.luck)
1158 buf.printf ("(luck%+d)", op->stats.luck); 1208 buf.printf ("(luck%+d)", op->stats.luck);
1159 1209
1160 if (QUERY_FLAG (op, FLAG_LIFESAVE)) buf << "(lifesaving)"; 1210 if (op->flag [FLAG_LIFESAVE]) buf << "(lifesaving)";
1161 if (QUERY_FLAG (op, FLAG_REFL_SPELL)) buf << "(reflect spells)"; 1211 if (op->flag [FLAG_REFL_SPELL]) buf << "(reflect spells)";
1162 if (QUERY_FLAG (op, FLAG_REFL_MISSILE)) buf << "(reflect missiles)"; 1212 if (op->flag [FLAG_REFL_MISSILE]) buf << "(reflect missiles)";
1163 if (QUERY_FLAG (op, FLAG_STEALTH)) buf << "(stealth)"; 1213 if (op->flag [FLAG_STEALTH]) buf << "(stealth)";
1164 1214
1165 if (op->slaying && op->type != FOOD) 1215 if (op->slaying && op->type != FOOD)
1166 buf.printf ("(slay %s)", &op->slaying); 1216 buf.printf ("(slay %s)", &op->slaying);
1167 1217
1168 if (op->type == SKILL_TOOL && op->skill) 1218 if (op->type == SKILL_TOOL && op->skill)
… …
1291 */ 1341 */
1292 if (msg) 1342 if (msg)
1293 { 1343 {
1294 if (type != EXIT && type != BOOK && type != CORPSE && !move_on && !has_dialogue ()) 1344 if (type != EXIT && type != BOOK && type != CORPSE && !move_on && !has_dialogue ())
1295 { 1345 {
1296 buf << '\r'; 1346 if (!need_identify ())
1297 1347 buf << '\r' << msg << '\n';
1298 /* This is just a hack so when identifying the items, we print 1348 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"; 1349 buf << '\r' << "The object has a story:\r" << msg;
1303
1304 buf << msg << '\n';
1305 } 1350 }
1306 } 1351 }
1307 else if (inv && inv->type == SPELL && flag [FLAG_IDENTIFIED] 1352 else if (inv
1353 && inv->msg
1354 && inv->type == SPELL
1355 && flag [FLAG_IDENTIFIED]
1308 && (type == SPELLBOOK || type == ROD || type == WAND 1356 && (type == SPELLBOOK || type == ROD || type == WAND
1309 || type == ROD || type == POTION || type == SCROLL)) 1357 || type == ROD || type == POTION || type == SCROLL))
1310 // for spellbooks and other stuff that contains spells, print the spell message, 1358 // for spellbooks and other stuff that contains spells, print the spell message,
1311 // unless the object has a custom message handled above. 1359 // unless the object has a custom message handled above.
1312 buf << '\r' << inv->msg << '\n'; 1360 buf << '\r' << inv->msg << '\n';
… …
1378object::query_inventory (object *who, const char *indent) 1426object::query_inventory (object *who, const char *indent)
1379{ 1427{
1380 static dynbuf_text buf; buf.clear (); 1428 static dynbuf_text buf; buf.clear ();
1381 1429
1382 for (object *tmp = inv; tmp; tmp = tmp->below) 1430 for (object *tmp = inv; tmp; tmp = tmp->below)
1383 if (who && QUERY_FLAG (who, FLAG_WIZ)) 1431 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 ()); 1432 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))) 1433 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 ()); 1434 buf.printf ("%s- %-36.36s %-8s\n", indent, tmp->query_name (), tmp->query_weight ());
1387 1435
1388 if (buf.size ()) 1436 if (buf.size ())
1389 buf.printf ("%s(total weight: %s)\n", indent, query_weight ()); 1437 buf.printf ("%s(total weight: %s)\n", indent, query_weight ());
1390 else 1438 else
… …
1403is_magical (const object *op) 1451is_magical (const object *op)
1404{ 1452{
1405 int i; 1453 int i;
1406 1454
1407 /* living creatures are considered non magical */ 1455 /* living creatures are considered non magical */
1408 if (QUERY_FLAG (op, FLAG_ALIVE)) 1456 if (op->flag [FLAG_ALIVE])
1409 return 0; 1457 return 0;
1410 1458
1411 /* This is a test for it being an artifact, as artifacts have titles */ 1459 /* This is a test for it being an artifact, as artifacts have titles */
1412 if (op->title != NULL) 1460 if (op->title != NULL)
1413 return 1; 1461 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)) 1467 (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; 1468 return 1;
1421 1469
1422 /* Check for stealty, speed, flying, or just plain magic in the boots */ 1470 /* Check for stealty, speed, flying, or just plain magic in the boots */
1423 /* Presume any boots that hvae a move_type are special. */ 1471 /* 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))) 1472 if (op->type == BOOTS && ((op->flag [FLAG_STEALTH] || op->move_type || op->stats.exp)))
1425 return 1; 1473 return 1;
1426 1474
1427 /* Take care of amulet/shield that reflects spells/missiles */ 1475 /* 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))) 1476 if ((op->type == AMULET || op->type == SHIELD) && (op->flag [FLAG_REFL_SPELL] || op->flag [FLAG_REFL_MISSILE]))
1429 return 1; 1477 return 1;
1430 1478
1431 /* Take care of helmet of xrays */ 1479 /* Take care of helmet of xrays */
1432 if (op->type == HELMET && QUERY_FLAG (op, FLAG_XRAYS)) 1480 if (op->type == HELMET && op->flag [FLAG_XRAYS])
1433 return 1; 1481 return 1;
1434 1482
1435 /* Potions & rods are always magical. Wands/staves are also magical, 1483 /* Potions & rods are always magical. Wands/staves are also magical,
1436 * assuming they still have any charges left. 1484 * assuming they still have any charges left.
1437 */ 1485 */
… …
1466 * be non magical. 1514 * be non magical.
1467 */ 1515 */
1468 return 0; 1516 return 0;
1469} 1517}
1470 1518
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/* 1519/*
1526 * Supposed to fix face-values as well here, but later. 1520 * Supposed to fix face-values as well here, but later.
1527 */ 1521 */
1528void 1522void
1529identify (object *op) 1523identify (object *op)
1530{ 1524{
1531 SET_FLAG (op, FLAG_IDENTIFIED); 1525 op->set_flag (FLAG_IDENTIFIED);
1532 CLEAR_FLAG (op, FLAG_KNOWN_MAGICAL); 1526 op->clr_flag (FLAG_KNOWN_MAGICAL);
1533 CLEAR_FLAG (op, FLAG_NO_SKILL_IDENT); 1527 op->clr_flag (FLAG_NO_SKILL_IDENT);
1534 1528
1535 /* 1529 /*
1536 * We want autojoining of equal objects: 1530 * We want autojoining of equal objects:
1537 */ 1531 */
1538 if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED)) 1532 if (op->flag [FLAG_CURSED] || op->flag [FLAG_DAMNED])
1539 SET_FLAG (op, FLAG_KNOWN_CURSED); 1533 op->set_flag (FLAG_KNOWN_CURSED);
1540 1534
1541 if (op->type == POTION) 1535 if (op->type == POTION)
1542 { 1536 {
1543 if (op->inv && op->randomitems) 1537 if (op->inv && op->randomitems)
1544 op->title = op->inv->name; 1538 op->title = op->inv->name;

Diff Legend

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