开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 查看源码
HANDLER.C
资源名称：mercwsrc.zip　[点击查看]
上传用户：kesirui
上传日期：2007-01-07
资源大小：263k
文件大小：35k
源码类别：

Internet/网络编程

开发平台：

WINDOWS

HANDLER.C：源码内容
  1. /***************************************************************************
  2.  *  Original Diku Mud copyright (C) 1990, 1991 by Sebastian Hammer,        *
  3.  *  Michael Seifert, Hans Henrik St{rfeldt, Tom Madsen, and Katja Nyboe.   *
  4.  *                                                                         *
  5.  *  Merc Diku Mud improvments copyright (C) 1992, 1993 by Michael          *
  6.  *  Chastain, Michael Quan, and Mitchell Tse.                              *
  7.  *                                                                         *
  8.  *  In order to use any part of this Merc Diku Mud, you must comply with   *
  9.  *  both the original Diku license in 'license.doc' as well the Merc       *
  10.  *  license in 'license.txt'.  In particular, you may not remove either of *
  11.  *  these copyright notices.                                               *
  12.  *                                                                         *
  13.  *  Much time and thought has gone into this software and you are          *
  14.  *  benefitting.  We hope that you share your changes too.  What goes      *
  15.  *  around, comes around.                                                  *
  16.  ***************************************************************************/
  18. #if defined(macintosh)
  19. #include <types.h>
  20. #else
  21. #include <sys/types.h>
  22. #endif
  23. #include <ctype.h>
  24. #include <stdio.h>
  25. #include <string.h>
  26. #include <time.h>
  27. #include "merc.h"
  31. AFFECT_DATA * affect_free;
  35. /*
  36.  * Local functions.
  37.  */
  38. void affect_modify args( ( CHAR_DATA *ch, AFFECT_DATA *paf, bool fAdd ) );
  42. /*
  43.  * Retrieve a character's trusted level for permission checking.
  44.  */
  45. int get_trust( CHAR_DATA *ch )
  46. {
  47.     if ( ch->desc != NULL && ch->desc->original != NULL )
  48. ch = ch->desc->original;
  50.     if ( ch->trust != 0 )
  51. return ch->trust;
  53.     if ( IS_NPC(ch) && ch->level >= LEVEL_HERO )
  54. return LEVEL_HERO - 1;
  55.     else
  56. return ch->level;
  57. }
  61. /*
  62.  * Retrieve a character's age.
  63.  */
  64. int get_age( CHAR_DATA *ch )
  65. {
  66.     return 17 + ( ch->played + (int) (current_time - ch->logon) ) / 14400;
  68.     /* 12240 assumes 30 second hours, 24 hours a day, 20 day - Kahn */
  69. }
  73. /*
  74.  * Retrieve character's current strength.
  75.  */
  76. int get_curr_str( CHAR_DATA *ch )
  77. {
  78.     int max;
  80.     if ( IS_NPC(ch) )
  81. return 13;
  83.     if ( class_table[ch->class].attr_prime == APPLY_STR )
  84. max = 25;
  85.     else
  86. max = 22;
  88.     return URANGE( 3, ch->pcdata->perm_str + ch->pcdata->mod_str, max );
  89. }
  93. /*
  94.  * Retrieve character's current intelligence.
  95.  */
  96. int get_curr_int( CHAR_DATA *ch )
  97. {
  98.     int max;
  100.     if ( IS_NPC(ch) )
  101. return 13;
  103.     if ( class_table[ch->class].attr_prime == APPLY_INT )
  104. max = 25;
  105.     else
  106. max = 22;
  108.     return URANGE( 3, ch->pcdata->perm_int + ch->pcdata->mod_int, max );
  109. }
  113. /*
  114.  * Retrieve character's current wisdom.
  115.  */
  116. int get_curr_wis( CHAR_DATA *ch )
  117. {
  118.     int max;
  120.     if ( IS_NPC(ch) )
  121. return 13;
  123.     if ( class_table[ch->class].attr_prime == APPLY_WIS )
  124. max = 25;
  125.     else
  126. max = 22;
  128.     return URANGE( 3, ch->pcdata->perm_wis + ch->pcdata->mod_wis, max );
  129. }
  133. /*
  134.  * Retrieve character's current dexterity.
  135.  */
  136. int get_curr_dex( CHAR_DATA *ch )
  137. {
  138.     int max;
  140.     if ( IS_NPC(ch) )
  141. return 13;
  143.     if ( class_table[ch->class].attr_prime == APPLY_DEX )
  144. max = 25;
  145.     else
  146. max = 22;
  148.     return URANGE( 3, ch->pcdata->perm_dex + ch->pcdata->mod_dex, max );
  149. }
  153. /*
  154.  * Retrieve character's current constitution.
  155.  */
  156. int get_curr_con( CHAR_DATA *ch )
  157. {
  158.     int max;
  160.     if ( IS_NPC(ch) )
  161. return 13;
  163.     if ( class_table[ch->class].attr_prime == APPLY_CON )
  164. max = 25;
  165.     else
  166. max = 22;
  168.     return URANGE( 3, ch->pcdata->perm_con + ch->pcdata->mod_con, max );
  169. }
  173. /*
  174.  * Retrieve a character's carry capacity.
  175.  */
  176. int can_carry_n( CHAR_DATA *ch )
  177. {
  178.     if ( !IS_NPC(ch) && ch->level >= LEVEL_IMMORTAL )
  179. return 1000;
  181.     if ( IS_NPC(ch) && IS_SET(ch->act, ACT_PET) )
  182. return 0;
  184.     return MAX_WEAR + 2 * get_curr_dex( ch ) / 2;
  185. }
  189. /*
  190.  * Retrieve a character's carry capacity.
  191.  */
  192. int can_carry_w( CHAR_DATA *ch )
  193. {
  194.     if ( !IS_NPC(ch) && ch->level >= LEVEL_IMMORTAL )
  195. return 1000000;
  197.     if ( IS_NPC(ch) && IS_SET(ch->act, ACT_PET) )
  198. return 0;
  200.     return str_app[get_curr_str(ch)].carry;
  201. }
  205. /*
  206.  * See if a string is one of the names of an object.
  207.  */
  208. /*
  209.  * New is_name sent in by Alander.
  210.  */
  212. bool is_name( const char *str, char *namelist )
  213. {
  214.     char name[MAX_INPUT_LENGTH];
  216.     for ( ; ; )
  217.     {
  218. namelist = one_argument( namelist, name );
  219. if ( name[0] == '' )
  220.     return FALSE;
  221. if ( !str_cmp( str, name ) )
  222.     return TRUE;
  223.     }
  224. }
  227. /*
  228.  * Apply or remove an affect to a character.
  229.  */
  230. void affect_modify( CHAR_DATA *ch, AFFECT_DATA *paf, bool fAdd )
  231. {
  232.     OBJ_DATA *wield;
  233.     int mod;
  235.     mod = paf->modifier;
  237.     if ( fAdd )
  238.     {
  239. SET_BIT( ch->affected_by, paf->bitvector );
  240.     }
  241.     else
  242.     {
  243. REMOVE_BIT( ch->affected_by, paf->bitvector );
  244. mod = 0 - mod;
  245.     }
  247.     if ( IS_NPC(ch) )
  248. return;
  250.     switch ( paf->location )
  251.     {
  252.     default:
  253. bug( "Affect_modify: unknown location %d.", paf->location );
  254. return;
  256.     case APPLY_NONE: break;
  257.     case APPLY_STR:           ch->pcdata->mod_str += mod; break;
  258.     case APPLY_DEX:           ch->pcdata->mod_dex += mod; break;
  259.     case APPLY_INT:           ch->pcdata->mod_int += mod; break;
  260.     case APPLY_WIS:           ch->pcdata->mod_wis += mod; break;
  261.     case APPLY_CON:           ch->pcdata->mod_con += mod; break;
  262.     case APPLY_SEX:           ch->sex += mod;
  263.        // @@@ This next bit is from the net...
  264.        if ( ch->sex < 0 || ch->sex > 2 )
  265.           ch->sex = 0;
  266.        break;
  267.     case APPLY_CLASS: break;
  268.     case APPLY_LEVEL: break;
  269.     case APPLY_AGE: break;
  270.     case APPLY_HEIGHT: break;
  271.     case APPLY_WEIGHT: break;
  272.     case APPLY_MANA:          ch->max_mana += mod; break;
  273.     case APPLY_HIT:           ch->max_hit += mod; break;
  274.     case APPLY_MOVE:          ch->max_move += mod; break;
  275.     case APPLY_GOLD: break;
  276.     case APPLY_EXP: break;
  277.     case APPLY_AC:            ch->armor += mod; break;
  278.     case APPLY_HITROLL:       ch->hitroll += mod; break;
  279.     case APPLY_DAMROLL:       ch->damroll += mod; break;
  280.     case APPLY_SAVING_PARA:   ch->saving_throw += mod; break;
  281.     case APPLY_SAVING_ROD:    ch->saving_throw += mod; break;
  282.     case APPLY_SAVING_PETRI:  ch->saving_throw += mod; break;
  283.     case APPLY_SAVING_BREATH: ch->saving_throw += mod; break;
  284.     case APPLY_SAVING_SPELL:  ch->saving_throw += mod; break;
  286.     // Don't fault on TFC zones
  287.     case APPLY_CHARISMA:     break;
  288.     case APPLY_LUC:          break;     case APPLY_NOSTEAL:      break;     case APPLY_NOSLEEP:      break;     case APPLY_NOSUMMON:     break;     case APPLY_NOCHARM:      break;     case APPLY_NOSEXCHANGE:  break;     case APPLY_TRUESEE:      break;     case APPLY_NOINFO:       break;
  289.     }
  291.     /*
  292.      * Check for weapon wielding.
  293.      * Guard against recursion (for weapons with affects).
  294.      */
  295.     if ( ( wield = get_eq_char( ch, WEAR_WIELD ) ) != NULL
  296.     &&   get_obj_weight(wield) > str_app[get_curr_str(ch)].wield )
  297.     {
  298. static int depth;
  300. if ( depth == 0 )
  301. {
  302.     depth++;
  303.     act( "You drop $p.", ch, wield, NULL, TO_CHAR );
  304.     act( "$n drops $p.", ch, wield, NULL, TO_ROOM );
  305.     obj_from_char( wield );
  306.     obj_to_room( wield, ch->in_room );
  307.     depth--;
  308. }
  309.     }
  311.     return;
  312. }
  316. /*
  317.  * Give an affect to a char.
  318.  */
  319. void affect_to_char( CHAR_DATA *ch, AFFECT_DATA *paf )
  320. {
  321.     AFFECT_DATA *paf_new;
  323.     if ( affect_free == NULL )
  324.     {
  325. paf_new = alloc_perm( sizeof(*paf_new) );
  326.     }
  327.     else
  328.     {
  329. paf_new = affect_free;
  330. affect_free = affect_free->next;
  331.     }
  333.     *paf_new = *paf;
  334.     paf_new->next = ch->affected;
  335.     ch->affected = paf_new;
  337.     affect_modify( ch, paf_new, TRUE );
  338.     return;
  339. }
  343. /*
  344.  * Remove an affect from a char.
  345.  */
  346. void affect_remove( CHAR_DATA *ch, AFFECT_DATA *paf )
  347. {
  348.     if ( ch->affected == NULL )
  349.     {
  350. bug( "Affect_remove: no affect.", 0 );
  351. return;
  352.     }
  354.     affect_modify( ch, paf, FALSE );
  356.     if ( paf == ch->affected )
  357.     {
  358. ch->affected = paf->next;
  359.     }
  360.     else
  361.     {
  362. AFFECT_DATA *prev;
  364. for ( prev = ch->affected; prev != NULL; prev = prev->next )
  365. {
  366.     if ( prev->next == paf )
  367.     {
  368. prev->next = paf->next;
  369. break;
  370.     }
  371. }
  373. if ( prev == NULL )
  374. {
  375.     bug( "Affect_remove: cannot find paf.", 0 );
  376.     return;
  377. }
  378.     }
  380.     paf->next = affect_free;
  381.     affect_free = paf->next;
  382.     return;
  383. }
  387. /*
  388.  * Strip all affects of a given sn.
  389.  */
  390. void affect_strip( CHAR_DATA *ch, int sn )
  391. {
  392.     AFFECT_DATA *paf;
  393.     AFFECT_DATA *paf_next;
  395.     for ( paf = ch->affected; paf != NULL; paf = paf_next )
  396.     {
  397. paf_next = paf->next;
  398. if ( paf->type == sn )
  399.     affect_remove( ch, paf );
  400.     }
  402.     return;
  403. }
  407. /*
  408.  * Return true if a char is affected by a spell.
  409.  */
  410. bool is_affected( CHAR_DATA *ch, int sn )
  411. {
  412.     AFFECT_DATA *paf;
  414.     for ( paf = ch->affected; paf != NULL; paf = paf->next )
  415.     {
  416. if ( paf->type == sn )
  417.     return TRUE;
  418.     }
  420.     return FALSE;
  421. }
  425. /*
  426.  * Add or enhance an affect.
  427.  */
  428. void affect_join( CHAR_DATA *ch, AFFECT_DATA *paf )
  429. {
  430.     AFFECT_DATA *paf_old;
  431.     bool found;
  433.     found = FALSE;
  434.     for ( paf_old = ch->affected; paf_old != NULL; paf_old = paf_old->next )
  435.     {
  436. if ( paf_old->type == paf->type )
  437. {
  438.     paf->duration += paf_old->duration;
  439.     paf->modifier += paf_old->modifier;
  440.     affect_remove( ch, paf_old );
  441.     break;
  442. }
  443.     }
  445.     affect_to_char( ch, paf );
  446.     return;
  447. }
  451. /*
  452.  * Move a char out of a room.
  453.  */
  454. void char_from_room( CHAR_DATA *ch )
  455. {
  456.     OBJ_DATA *obj;
  458.     if ( ch->in_room == NULL )
  459.     {
  460. bug( "Char_from_room: NULL.", 0 );
  461. return;
  462.     }
  464.     if ( !IS_NPC(ch) )
  465. --ch->in_room->area->nplayer;
  467.     if ( ( obj = get_eq_char( ch, WEAR_LIGHT ) ) != NULL
  468.     &&   obj->item_type == ITEM_LIGHT
  469.     &&   obj->value[2] != 0
  470.     &&   ch->in_room->light > 0 )
  471. --ch->in_room->light;
  473.     if ( ch == ch->in_room->people )
  474.     {
  475. ch->in_room->people = ch->next_in_room;
  476.     }
  477.     else
  478.     {
  479. CHAR_DATA *prev;
  481. for ( prev = ch->in_room->people; prev; prev = prev->next_in_room )
  482. {
  483.     if ( prev->next_in_room == ch )
  484.     {
  485. prev->next_in_room = ch->next_in_room;
  486. break;
  487.     }
  488. }
  490. if ( prev == NULL )
  491.     bug( "Char_from_room: ch not found.", 0 );
  492.     }
  494.     ch->in_room      = NULL;
  495.     ch->next_in_room = NULL;
  496.     return;
  497. }
  501. /*
  502.  * Move a char into a room.
  503.  */
  504. void char_to_room( CHAR_DATA *ch, ROOM_INDEX_DATA *pRoomIndex )
  505. {
  506.     OBJ_DATA *obj;
  508.     if ( pRoomIndex == NULL )
  509.     {
  510. bug( "Char_to_room: NULL.", 0 );
  511. return;
  512.     }
  514.     ch->in_room = pRoomIndex;
  515.     ch->next_in_room = pRoomIndex->people;
  516.     pRoomIndex->people = ch;
  518.     if ( !IS_NPC(ch) )
  519. ++ch->in_room->area->nplayer;
  521.     if ( ( obj = get_eq_char( ch, WEAR_LIGHT ) ) != NULL
  522.     &&   obj->item_type == ITEM_LIGHT
  523.     &&   obj->value[2] != 0 )
  524. ++ch->in_room->light;
  526.     return;
  527. }
  531. /*
  532.  * Give an obj to a char.
  533.  */
  534. void obj_to_char( OBJ_DATA *obj, CHAR_DATA *ch )
  535. {
  536.     obj->next_content  = ch->carrying;
  537.     ch->carrying  = obj;
  538.     obj->carried_by  = ch;
  539.     obj->in_room  = NULL;
  540.     obj->in_obj  = NULL;
  541.     ch->carry_number += get_obj_number( obj );
  542.     ch->carry_weight += get_obj_weight( obj );
  543. }
  547. /*
  548.  * Take an obj from its character.
  549.  */
  550. void obj_from_char( OBJ_DATA *obj )
  551. {
  552.     CHAR_DATA *ch;
  554.     if ( ( ch = obj->carried_by ) == NULL )
  555.     {
  556. bug( "Obj_from_char: null ch.", 0 );
  557. return;
  558.     }
  560.     if ( obj->wear_loc != WEAR_NONE )
  561. unequip_char( ch, obj );
  563.     if ( ch->carrying == obj )
  564.     {
  565. ch->carrying = obj->next_content;
  566.     }
  567.     else
  568.     {
  569. OBJ_DATA *prev;
  571. for ( prev = ch->carrying; prev != NULL; prev = prev->next_content )
  572. {
  573.     if ( prev->next_content == obj )
  574.     {
  575. prev->next_content = obj->next_content;
  576. break;
  577.     }
  578. }
  580. if ( prev == NULL )
  581.     bug( "Obj_from_char: obj not in list.", 0 );
  582.     }
  584.     obj->carried_by  = NULL;
  585.     obj->next_content  = NULL;
  586.     ch->carry_number -= get_obj_number( obj );
  587.     ch->carry_weight -= get_obj_weight( obj );
  588.     return;
  589. }
  593. /*
  594.  * Find the ac value of an obj, including position effect.
  595.  */
  596. int apply_ac( OBJ_DATA *obj, int iWear )
  597. {
  598.     if ( obj->item_type != ITEM_ARMOR )
  599. return 0;
  601.     switch ( iWear )
  602.     {
  603.     case WEAR_BODY: return 3 * obj->value[0];
  604.     case WEAR_HEAD: return 2 * obj->value[0];
  605.     case WEAR_LEGS: return 2 * obj->value[0];
  606.     case WEAR_FEET: return     obj->value[0];
  607.     case WEAR_HANDS: return     obj->value[0];
  608.     case WEAR_ARMS: return     obj->value[0];
  609.     case WEAR_SHIELD: return     obj->value[0];
  610.     case WEAR_FINGER_L: return     obj->value[0];
  611.     case WEAR_FINGER_R: return     obj->value[0];
  612.     case WEAR_NECK_1: return     obj->value[0];
  613.     case WEAR_NECK_2: return     obj->value[0];
  614.     case WEAR_ABOUT: return 2 * obj->value[0];
  615.     case WEAR_WAIST: return     obj->value[0];
  616.     case WEAR_WRIST_L: return     obj->value[0];
  617.     case WEAR_WRIST_R: return     obj->value[0];
  618.     case WEAR_HOLD: return     obj->value[0];
  619.     }
  621.     return 0;
  622. }
  626. /*
  627.  * Find a piece of eq on a character.
  628.  */
  629. OBJ_DATA *get_eq_char( CHAR_DATA *ch, int iWear )
  630. {
  631.     OBJ_DATA *obj;
  633.     for ( obj = ch->carrying; obj != NULL; obj = obj->next_content )
  634.     {
  635. if ( obj->wear_loc == iWear )
  636.     return obj;
  637.     }
  639.     return NULL;
  640. }
  644. /*
  645.  * Equip a char with an obj.
  646.  */
  647. void equip_char( CHAR_DATA *ch, OBJ_DATA *obj, int iWear )
  648. {
  649.     AFFECT_DATA *paf;
  651.     if ( get_eq_char( ch, iWear ) != NULL )
  652.     {
  653. bug( "Equip_char: already equipped (%d).", iWear );
  654. return;
  655.     }
  657.     if ( ( IS_OBJ_STAT(obj, ITEM_ANTI_EVIL)    && IS_EVIL(ch)    )
  658.     ||   ( IS_OBJ_STAT(obj, ITEM_ANTI_GOOD)    && IS_GOOD(ch)    )
  659.     ||   ( IS_OBJ_STAT(obj, ITEM_ANTI_NEUTRAL) && IS_NEUTRAL(ch) ) )
  660.     {
  661. /*
  662.  * Thanks to Morgenes for the bug fix here!
  663.  */
  664. act( "You are zapped by $p and drop it.", ch, obj, NULL, TO_CHAR );
  665. act( "$n is zapped by $p and drops it.",  ch, obj, NULL, TO_ROOM );
  666. obj_from_char( obj );
  667. obj_to_room( obj, ch->in_room );
  668. return;
  669.     }
  671.     ch->armor       -= apply_ac( obj, iWear );
  672.     obj->wear_loc  = iWear;
  674.     for ( paf = obj->pIndexData->affected; paf != NULL; paf = paf->next )
  675. affect_modify( ch, paf, TRUE );
  676.     for ( paf = obj->affected; paf != NULL; paf = paf->next )
  677. affect_modify( ch, paf, TRUE );
  679.     if ( obj->item_type == ITEM_LIGHT
  680.     &&   obj->value[2] != 0
  681.     &&   ch->in_room != NULL )
  682. ++ch->in_room->light;
  684.     return;
  685. }
  689. /*
  690.  * Unequip a char with an obj.
  691.  */
  692. void unequip_char( CHAR_DATA *ch, OBJ_DATA *obj )
  693. {
  694.     AFFECT_DATA *paf;
  696.     if ( obj->wear_loc == WEAR_NONE )
  697.     {
  698. bug( "Unequip_char: already unequipped.", 0 );
  699. return;
  700.     }
  702.     ch->armor += apply_ac( obj, obj->wear_loc );
  703.     obj->wear_loc  = -1;
  705.     for ( paf = obj->pIndexData->affected; paf != NULL; paf = paf->next )
  706. affect_modify( ch, paf, FALSE );
  707.     for ( paf = obj->affected; paf != NULL; paf = paf->next )
  708. affect_modify( ch, paf, FALSE );
  710.     if ( obj->item_type == ITEM_LIGHT
  711.     &&   obj->value[2] != 0
  712.     &&   ch->in_room != NULL
  713.     &&   ch->in_room->light > 0 )
  714. --ch->in_room->light;
  716.     return;
  717. }
  721. /*
  722.  * Count occurrences of an obj in a list.
  723.  */
  724. int count_obj_list( OBJ_INDEX_DATA *pObjIndex, OBJ_DATA *list )
  725. {
  726.     OBJ_DATA *obj;
  727.     int nMatch;
  729.     nMatch = 0;
  730.     for ( obj = list; obj != NULL; obj = obj->next_content )
  731.     {
  732. if ( obj->pIndexData == pObjIndex )
  733.     nMatch++;
  734.     }
  736.     return nMatch;
  737. }
  741. /*
  742.  * Move an obj out of a room.
  743.  */
  744. void obj_from_room( OBJ_DATA *obj )
  745. {
  746.     ROOM_INDEX_DATA *in_room;
  748.     if ( ( in_room = obj->in_room ) == NULL )
  749.     {
  750. bug( "obj_from_room: NULL.", 0 );
  751. return;
  752.     }
  754.     if ( obj == in_room->contents )
  755.     {
  756. in_room->contents = obj->next_content;
  757.     }
  758.     else
  759.     {
  760. OBJ_DATA *prev;
  762. for ( prev = in_room->contents; prev; prev = prev->next_content )
  763. {
  764.     if ( prev->next_content == obj )
  765.     {
  766. prev->next_content = obj->next_content;
  767. break;
  768.     }
  769. }
  771. if ( prev == NULL )
  772. {
  773.     bug( "Obj_from_room: obj not found.", 0 );
  774.     return;
  775. }
  776.     }
  778.     obj->in_room      = NULL;
  779.     obj->next_content = NULL;
  780.     return;
  781. }
  785. /*
  786.  * Move an obj into a room.
  787.  */
  788. void obj_to_room( OBJ_DATA *obj, ROOM_INDEX_DATA *pRoomIndex )
  789. {
  790.     obj->next_content = pRoomIndex->contents;
  791.     pRoomIndex->contents = obj;
  792.     obj->in_room = pRoomIndex;
  793.     obj->carried_by = NULL;
  794.     obj->in_obj = NULL;
  795.     return;
  796. }
  800. /*
  801.  * Move an object into an object.
  802.  */
  803. void obj_to_obj( OBJ_DATA *obj, OBJ_DATA *obj_to )
  804. {
  805.     obj->next_content = obj_to->contains;
  806.     obj_to->contains = obj;
  807.     obj->in_obj = obj_to;
  808.     obj->in_room = NULL;
  809.     obj->carried_by = NULL;
  811.     for ( ; obj_to != NULL; obj_to = obj_to->in_obj )
  812.     {
  813. if ( obj_to->carried_by != NULL )
  814. {
  815. //     obj_to->carried_by->carry_number += get_obj_number( obj );
  816.     obj_to->carried_by->carry_weight += get_obj_weight( obj );
  817. }
  818.     }
  820.     return;
  821. }
  825. /*
  826.  * Move an object out of an object.
  827.  */
  828. void obj_from_obj( OBJ_DATA *obj )
  829. {
  830.     OBJ_DATA *obj_from;
  832.     if ( ( obj_from = obj->in_obj ) == NULL )
  833.     {
  834. bug( "Obj_from_obj: null obj_from.", 0 );
  835. return;
  836.     }
  838.     if ( obj == obj_from->contains )
  839.     {
  840. obj_from->contains = obj->next_content;
  841.     }
  842.     else
  843.     {
  844. OBJ_DATA *prev;
  846. for ( prev = obj_from->contains; prev; prev = prev->next_content )
  847. {
  848.     if ( prev->next_content == obj )
  849.     {
  850. prev->next_content = obj->next_content;
  851. break;
  852.     }
  853. }
  855. if ( prev == NULL )
  856. {
  857.     bug( "Obj_from_obj: obj not found.", 0 );
  858.     return;
  859. }
  860.     }
  862.     obj->next_content = NULL;
  863.     obj->in_obj       = NULL;
  865.     for ( ; obj_from != NULL; obj_from = obj_from->in_obj )
  866.     {
  867. if ( obj_from->carried_by != NULL )
  868. {
  869. //     obj_from->carried_by->carry_number -= get_obj_number( obj );
  870.     obj_from->carried_by->carry_weight -= get_obj_weight( obj );
  871. }
  872.     }
  874.     return;
  875. }
  879. /*
  880.  * Extract an obj from the world.
  881.  */
  882. void extract_obj( OBJ_DATA *obj )
  883. {
  884.     OBJ_DATA *obj_content;
  885.     OBJ_DATA *obj_next;
  887.     if ( obj->in_room != NULL )
  888. obj_from_room( obj );
  889.     else if ( obj->carried_by != NULL )
  890. obj_from_char( obj );
  891.     else if ( obj->in_obj != NULL )
  892. obj_from_obj( obj );
  894.     for ( obj_content = obj->contains; obj_content; obj_content = obj_next )
  895.     {
  896. obj_next = obj_content->next_content;
  897. extract_obj( obj->contains );
  898.     }
  900.     if ( object_list == obj )
  901.     {
  902. object_list = obj->next;
  903.     }
  904.     else
  905.     {
  906. OBJ_DATA *prev;
  908. for ( prev = object_list; prev != NULL; prev = prev->next )
  909. {
  910.     if ( prev->next == obj )
  911.     {
  912. prev->next = obj->next;
  913. break;
  914.     }
  915. }
  917. if ( prev == NULL )
  918. {
  919.     bug( "Extract_obj: obj %d not found.", obj->pIndexData->vnum );
  920.     return;
  921. }
  922.     }
  924.     {
  925. AFFECT_DATA *paf;
  926. AFFECT_DATA *paf_next;
  928. for ( paf = obj->affected; paf != NULL; paf = paf_next )
  929. {
  930.     paf_next    = paf->next;
  931.     paf->next   = affect_free;
  932.     affect_free = paf;
  933. }
  934.     }
  936.     {
  937. EXTRA_DESCR_DATA *ed;
  938. EXTRA_DESCR_DATA *ed_next;
  940. for ( ed = obj->extra_descr; ed != NULL; ed = ed_next )
  941. {
  942.     ed_next = ed->next;
  943.     free_string( ed->description );
  944.     free_string( ed->keyword     );
  945.     extra_descr_free = ed;
  946. }
  947.     }
  949.     free_string( obj->name        );
  950.     free_string( obj->description );
  951.     free_string( obj->short_descr );
  952.     --obj->pIndexData->count;
  953.     obj->next = obj_free;
  954.     obj_free = obj;
  955.     return;
  956. }
  960. /*
  961.  * Extract a char from the world.
  962.  */
  963. void extract_char( CHAR_DATA *ch, bool fPull )
  964. {
  965.     CHAR_DATA *wch;
  966.     OBJ_DATA *obj;
  967.     OBJ_DATA *obj_next;
  969.     if ( ch->in_room == NULL )
  970.     {
  971. bug( "Extract_char: NULL.", 0 );
  972. return;
  973.     }
  975.     if ( fPull )
  976. die_follower( ch );
  978.     stop_fighting( ch, TRUE );
  980.     for ( obj = ch->carrying; obj != NULL; obj = obj_next )
  981.     {
  982. obj_next = obj->next_content;
  983. extract_obj( obj );
  984.     }
  985.     
  986.     char_from_room( ch );
  988.     if ( !fPull )
  989.     {
  990. /* char_to_room( ch, get_room_index( ROOM_VNUM_ALTAR ) );*/
  991. char_to_room( ch, get_room_index( race_table[ch->race].city_temple ) );
  992. return;
  993.     }
  995.     if ( IS_NPC(ch) )
  996. --ch->pIndexData->count;
  998.     if ( ch->desc != NULL && ch->desc->original != NULL )
  999. do_return( ch, "" );
  1001.     for ( wch = char_list; wch != NULL; wch = wch->next )
  1002.     {
  1003. if ( wch->reply == ch )
  1004.     wch->reply = NULL;
  1005.     }
  1007.     if ( ch == char_list )
  1008.     {
  1009.        char_list = ch->next;
  1010.     }
  1011.     else
  1012.     {
  1013. CHAR_DATA *prev;
  1015. for ( prev = char_list; prev != NULL; prev = prev->next )
  1016. {
  1017.     if ( prev->next == ch )
  1018.     {
  1019. prev->next = ch->next;
  1020. break;
  1021.     }
  1022. }
  1024. if ( prev == NULL )
  1025. {
  1026.     bug( "Extract_char: char not found.", 0 );
  1027.     return;
  1028. }
  1029.     }
  1031.     if ( ch->desc )
  1032. ch->desc->character = NULL;
  1033.     free_char( ch );
  1034.     return;
  1035. }
  1039. /*
  1040.  * Find a char in the room.
  1041.  */
  1042. CHAR_DATA *get_char_room( CHAR_DATA *ch, char *argument )
  1043. {
  1044.     char arg[MAX_INPUT_LENGTH];
  1045.     CHAR_DATA *rch;
  1046.     int number;
  1047.     int count;
  1049.     number = number_argument( argument, arg );
  1050.     count  = 0;
  1051.     if ( !str_cmp( arg, "self" ) )
  1052. return ch;
  1053.     for ( rch = ch->in_room->people; rch != NULL; rch = rch->next_in_room )
  1054.     {
  1055. if ( !can_see( ch, rch ) || !is_name( arg, rch->name ) )
  1056.     continue;
  1057. if ( ++count == number )
  1058.     return rch;
  1059.     }
  1061.     return NULL;
  1062. }
  1067. /*
  1068.  * Find a char in the world.
  1069.  */
  1070. CHAR_DATA *get_char_world( CHAR_DATA *ch, char *argument )
  1071. {
  1072.     char arg[MAX_INPUT_LENGTH];
  1073.     CHAR_DATA *wch;
  1074.     int number;
  1075.     int count;
  1077.     if ( ( wch = get_char_room( ch, argument ) ) != NULL )
  1078. return wch;
  1080.     number = number_argument( argument, arg );
  1081.     count  = 0;
  1082.     for ( wch = char_list; wch != NULL ; wch = wch->next )
  1083.     {
  1084. if ( !can_see( ch, wch ) || !is_name( arg, wch->name ) )
  1085.     continue;
  1086. if ( ++count == number )
  1087.     return wch;
  1088.     }
  1090.     return NULL;
  1091. }
  1095. /*
  1096.  * Find some object with a given index data.
  1097.  * Used by area-reset 'P' command.
  1098.  */
  1099. OBJ_DATA *get_obj_type( OBJ_INDEX_DATA *pObjIndex )
  1100. {
  1101.     OBJ_DATA *obj;
  1103.     for ( obj = object_list; obj != NULL; obj = obj->next )
  1104.     {
  1105. if ( obj->pIndexData == pObjIndex )
  1106.     return obj;
  1107.     }
  1109.     return NULL;
  1110. }
  1113. /*
  1114.  * Find an obj in a list.
  1115.  */
  1116. OBJ_DATA *get_obj_list( CHAR_DATA *ch, char *argument, OBJ_DATA *list )
  1117. {
  1118.     char arg[MAX_INPUT_LENGTH];
  1119.     OBJ_DATA *obj;
  1120.     int number;
  1121.     int count;
  1123.     number = number_argument( argument, arg );
  1124.     count  = 0;
  1125.     for ( obj = list; obj != NULL; obj = obj->next_content )
  1126.     {
  1127. if ( can_see_obj( ch, obj ) && is_name( arg, obj->name ) )
  1128. {
  1129.     if ( ++count == number )
  1130. return obj;
  1131. }
  1132.     }
  1134.     return NULL;
  1135. }
  1139. /*
  1140.  * Find an obj in player's inventory.
  1141.  */
  1142. OBJ_DATA *get_obj_carry( CHAR_DATA *ch, char *argument )
  1143. {
  1144.     char arg[MAX_INPUT_LENGTH];
  1145.     OBJ_DATA *obj;
  1146.     int number;
  1147.     int count;
  1149.     number = number_argument( argument, arg );
  1150.     count  = 0;
  1151.     for ( obj = ch->carrying; obj != NULL; obj = obj->next_content )
  1152.     {
  1153. if ( obj->wear_loc == WEAR_NONE
  1154. &&   can_see_obj( ch, obj )
  1155. &&   is_name( arg, obj->name ) )
  1156. {
  1157.     if ( ++count == number )
  1158. return obj;
  1159. }
  1160.     }
  1162.     return NULL;
  1163. }
  1167. /*
  1168.  * Find an obj in player's equipment.
  1169.  */
  1170. OBJ_DATA *get_obj_wear( CHAR_DATA *ch, char *argument )
  1171. {
  1172.     char arg[MAX_INPUT_LENGTH];
  1173.     OBJ_DATA *obj;
  1174.     int number;
  1175.     int count;
  1177.     number = number_argument( argument, arg );
  1178.     count  = 0;
  1179.     for ( obj = ch->carrying; obj != NULL; obj = obj->next_content )
  1180.     {
  1181. if ( obj->wear_loc != WEAR_NONE
  1182. &&   can_see_obj( ch, obj )
  1183. &&   is_name( arg, obj->name ) )
  1184. {
  1185.     if ( ++count == number )
  1186. return obj;
  1187. }
  1188.     }
  1190.     return NULL;
  1191. }
  1195. /*
  1196.  * Find an obj in the room or in inventory.
  1197.  */
  1198. OBJ_DATA *get_obj_here( CHAR_DATA *ch, char *argument )
  1199. {
  1200.     OBJ_DATA *obj;
  1202.     obj = get_obj_list( ch, argument, ch->in_room->contents );
  1203.     if ( obj != NULL )
  1204. return obj;
  1206.     if ( ( obj = get_obj_carry( ch, argument ) ) != NULL )
  1207. return obj;
  1209.     if ( ( obj = get_obj_wear( ch, argument ) ) != NULL )
  1210. return obj;
  1212.     return NULL;
  1213. }
  1217. /*
  1218.  * Find an obj in the world.
  1219.  */
  1220. OBJ_DATA *get_obj_world( CHAR_DATA *ch, char *argument )
  1221. {
  1222.     char arg[MAX_INPUT_LENGTH];
  1223.     OBJ_DATA *obj;
  1224.     int number;
  1225.     int count;
  1227.     if ( ( obj = get_obj_here( ch, argument ) ) != NULL )
  1228. return obj;
  1230.     number = number_argument( argument, arg );
  1231.     count  = 0;
  1232.     for ( obj = object_list; obj != NULL; obj = obj->next )
  1233.     {
  1234. if ( can_see_obj( ch, obj ) && is_name( arg, obj->name ) )
  1235. {
  1236.     if ( ++count == number )
  1237. return obj;
  1238. }
  1239.     }
  1241.     return NULL;
  1242. }
  1246. /*
  1247.  * Create a 'money' obj.
  1248.  */
  1249. OBJ_DATA *create_money( int amount )
  1250. {
  1251.     char buf[MAX_STRING_LENGTH];
  1252.     OBJ_DATA *obj;
  1254.     if ( amount <= 0 )
  1255.     {
  1256. bug( "Create_money: zero or negative money %d.", amount );
  1257. amount = 1;
  1258.     }
  1260.     if ( amount == 1 )
  1261.     {
  1262. obj = create_object( get_obj_index( OBJ_VNUM_MONEY_ONE ), 0 );
  1263.     }
  1264.     else
  1265.     {
  1266. obj = create_object( get_obj_index( OBJ_VNUM_MONEY_SOME ), 0 );
  1267. sprintf( buf, obj->short_descr, amount );
  1268. free_string( obj->short_descr );
  1269. obj->short_descr = str_dup( buf );
  1270. obj->value[0] = amount;
  1271.     }
  1273.     return obj;
  1274. }
  1278. /*
  1279.  * Return # of objects which an object counts as.
  1280.  * Thanks to Tony Chamberlain for the correct recursive code here.
  1281.  */
  1282. int get_obj_number( OBJ_DATA *obj )
  1283. {
  1284. /*
  1285.     int number;
  1287.     number = 0;
  1288.     if ( obj->item_type == ITEM_CONTAINER )
  1289.       for ( obj = obj->contains; obj != NULL; obj = obj->next_content )
  1290. number += get_obj_number( obj );
  1291.     else
  1292. number = 1;
  1294.     return number;
  1295. */
  1296.     return 1;
  1297. }
  1301. /*
  1302.  * Return weight of an object, including weight of contents.
  1303.  */
  1304. int get_obj_weight( OBJ_DATA *obj )
  1305. {
  1306.     int weight;
  1308.     weight = obj->weight;
  1309.     for ( obj = obj->contains; obj != NULL; obj = obj->next_content )
  1310. weight += get_obj_weight( obj );
  1312.     return weight;
  1313. }
  1317. /*
  1318.  * True if room is dark.
  1319.  */
  1320. bool room_is_dark( ROOM_INDEX_DATA *pRoomIndex )
  1321. {
  1322.     if ( pRoomIndex->light > 0 )
  1323. return FALSE;
  1325.     if ( IS_SET(pRoomIndex->room_flags, ROOM_DARK) )
  1326. return TRUE;
  1328.     if ( pRoomIndex->sector_type == SECT_INSIDE
  1329.     ||   pRoomIndex->sector_type == SECT_CITY )
  1330. return FALSE;
  1332.     if ( weather_info.sunlight == SUN_SET
  1333.     ||   weather_info.sunlight == SUN_DARK )
  1334. return TRUE;
  1336.     return FALSE;
  1337. }
  1341. /*
  1342.  * True if room is private.
  1343.  */
  1344. bool room_is_private( ROOM_INDEX_DATA *pRoomIndex )
  1345. {
  1346.     CHAR_DATA *rch;
  1347.     int count;
  1349.     count = 0;
  1350.     for ( rch = pRoomIndex->people; rch != NULL; rch = rch->next_in_room )
  1351. count++;
  1353.     if ( IS_SET(pRoomIndex->room_flags, ROOM_PRIVATE)  && count >= 2 )
  1354. return TRUE;
  1356.     if ( IS_SET(pRoomIndex->room_flags, ROOM_SOLITARY) && count >= 1 )
  1357. return TRUE;
  1359.     return FALSE;
  1360. }
  1364. /*
  1365.  * True if char can see victim.
  1366.  */
  1367. bool can_see( CHAR_DATA *ch, CHAR_DATA *victim )
  1368. {
  1369.     if ( ch == victim )
  1370. return TRUE;
  1371.     
  1372.     if ( !IS_NPC(victim)
  1373.     &&   IS_SET(victim->act, PLR_WIZINVIS)
  1374.     &&   get_trust( ch ) < get_trust( victim ) )
  1375. return FALSE;
  1377.     if ( !IS_NPC(ch) && IS_SET(ch->act, PLR_HOLYLIGHT) )
  1378. return TRUE;
  1380.     if ( IS_AFFECTED(ch, AFF_BLIND) )
  1381. return FALSE;
  1383.     if ( room_is_dark( ch->in_room ) && !IS_AFFECTED(ch, AFF_INFRARED) )
  1384. return FALSE;
  1386.     if ( IS_AFFECTED(victim, AFF_INVISIBLE)
  1387.     &&   !IS_AFFECTED(ch, AFF_DETECT_INVIS) )
  1388. return FALSE;
  1390.     if ( IS_AFFECTED(victim, AFF_HIDE)
  1391.     &&   !IS_AFFECTED(ch, AFF_DETECT_HIDDEN)
  1392.     &&   victim->fighting == NULL
  1393.     &&   ( IS_NPC(ch) ? !IS_NPC(victim) : IS_NPC(victim) ) )
  1394. return FALSE;
  1396.     return TRUE;
  1397. }
  1401. /*
  1402.  * True if char can see obj.
  1403.  */
  1404. bool can_see_obj( CHAR_DATA *ch, OBJ_DATA *obj )
  1405. {
  1406.     if ( !IS_NPC(ch) && IS_SET(ch->act, PLR_HOLYLIGHT) )
  1407. return TRUE;
  1409.     if ( obj->item_type == ITEM_POTION )
  1410. return TRUE;
  1412.     if ( IS_AFFECTED( ch, AFF_BLIND ) )
  1413. return FALSE;
  1415.     if ( obj->item_type == ITEM_LIGHT && obj->value[2] != 0 )
  1416. return TRUE;
  1418.     if ( room_is_dark( ch->in_room ) && !IS_AFFECTED(ch, AFF_INFRARED) )
  1419. return FALSE;
  1421.     if ( IS_SET(obj->extra_flags, ITEM_INVIS)
  1422.     &&   !IS_AFFECTED(ch, AFF_DETECT_INVIS) )
  1423. return FALSE;
  1425.     return TRUE;
  1426. }
  1430. /*
  1431.  * True if char can drop obj.
  1432.  */
  1433. bool can_drop_obj( CHAR_DATA *ch, OBJ_DATA *obj )
  1434. {
  1435.     if ( !IS_SET(obj->extra_flags, ITEM_NODROP) )
  1436. return TRUE;
  1438.     if ( !IS_NPC(ch) && ch->level >= LEVEL_IMMORTAL )
  1439. return TRUE;
  1441.     return FALSE;
  1442. }
  1446. /*
  1447.  * Return ascii name of an item type.
  1448.  */
  1449. char *item_type_name( OBJ_DATA *obj )
  1450. {
  1451.     switch ( obj->item_type )
  1452.     {
  1453.     case ITEM_LIGHT: return "light";
  1454.     case ITEM_SCROLL: return "scroll";
  1455.     case ITEM_WAND: return "wand";
  1456.     case ITEM_STAFF: return "staff";
  1457.     case ITEM_WEAPON: return "weapon";
  1458.     case ITEM_TREASURE: return "treasure";
  1459.     case ITEM_ARMOR: return "armor";
  1460.     case ITEM_POTION: return "potion";
  1461.     case ITEM_FURNITURE: return "furniture";
  1462.     case ITEM_TRASH: return "trash";
  1463.     case ITEM_CONTAINER: return "container";
  1464.     case ITEM_DRINK_CON: return "drink container";
  1465.     case ITEM_KEY: return "key";
  1466.     case ITEM_FOOD: return "food";
  1467.     case ITEM_MONEY: return "money";
  1468.     case ITEM_BOAT: return "boat";
  1469.     case ITEM_CORPSE_NPC: return "npc corpse";
  1470.     case ITEM_CORPSE_PC: return "pc corpse";
  1471.     case ITEM_FOUNTAIN: return "fountain";
  1472.     case ITEM_PILL: return "pill";
  1473.     }
  1475.     bug( "Item_type_name: unknown type %d.", obj->item_type );
  1476.     return "(unknown)";
  1477. }
  1481. /*
  1482.  * Return ascii name of an affect location.
  1483.  */
  1484. char *affect_loc_name( int location )
  1485. {
  1486.     switch ( location )
  1487.     {
  1488.     case APPLY_NONE: return "none";
  1489.     case APPLY_STR: return "strength";
  1490.     case APPLY_DEX: return "dexterity";
  1491.     case APPLY_INT: return "intelligence";
  1492.     case APPLY_WIS: return "wisdom";
  1493.     case APPLY_CON: return "constitution";
  1494.     case APPLY_SEX: return "sex";
  1495.     case APPLY_CLASS: return "class";
  1496.     case APPLY_LEVEL: return "level";
  1497.     case APPLY_AGE: return "age";
  1498.     case APPLY_MANA: return "mana";
  1499.     case APPLY_HIT: return "hp";
  1500.     case APPLY_MOVE: return "moves";
  1501.     case APPLY_GOLD: return "gold";
  1502.     case APPLY_EXP: return "experience";
  1503.     case APPLY_AC: return "armor class";
  1504.     case APPLY_HITROLL: return "hit roll";
  1505.     case APPLY_DAMROLL: return "damage roll";
  1506.     case APPLY_SAVING_PARA: return "save vs paralysis";
  1507.     case APPLY_SAVING_ROD: return "save vs rod";
  1508.     case APPLY_SAVING_PETRI: return "save vs petrification";
  1509.     case APPLY_SAVING_BREATH: return "save vs breath";
  1510.     case APPLY_SAVING_SPELL: return "save vs spell";
  1512.     // Don't fault on TFC zones
  1513.     case APPLY_CHARISMA:     return "chr";
  1514.     case APPLY_LUC:          return "luck";     case APPLY_NOSTEAL:      return "anti-theft";     case APPLY_NOSLEEP:      return "nosleep";     // steadfastness?     case APPLY_NOSUMMON:     return "blocking";     case APPLY_NOCHARM:      return "nocharm";     // steadfastness?     case APPLY_NOSEXCHANGE:  return "familiarity";     case APPLY_TRUESEE:      return "true seeing";     case APPLY_NOINFO:       return "obscurement";
  1515.     }
  1517.     bug( "Affect_location_name: unknown location %d.", location );
  1518.     return "(unknown)";
  1519. }
  1523. /*
  1524.  * Return ascii name of an affect bit vector.
  1525.  */
  1526. char *affect_bit_name( int vector )
  1527. {
  1528.     static char buf[512];
  1530.     buf[0] = '';
  1531.     if ( vector & AFF_BLIND         ) strcat( buf, " blind"         );
  1532.     if ( vector & AFF_INVISIBLE     ) strcat( buf, " invisible"     );
  1533.     if ( vector & AFF_DETECT_EVIL   ) strcat( buf, " detect_evil"   );
  1534.     if ( vector & AFF_DETECT_INVIS  ) strcat( buf, " detect_invis"  );
  1535.     if ( vector & AFF_DETECT_MAGIC  ) strcat( buf, " detect_magic"  );
  1536.     if ( vector & AFF_DETECT_HIDDEN ) strcat( buf, " detect_hidden" );
  1537.     if ( vector & AFF_HOLD          ) strcat( buf, " hold"          );
  1538.     if ( vector & AFF_SANCTUARY     ) strcat( buf, " sanctuary"     );
  1539.     if ( vector & AFF_FAERIE_FIRE   ) strcat( buf, " faerie_fire"   );
  1540.     if ( vector & AFF_INFRARED      ) strcat( buf, " infrared"      );
  1541.     if ( vector & AFF_CURSE         ) strcat( buf, " curse"         );
  1542.     if ( vector & AFF_FLAMING       ) strcat( buf, " flaming"       );
  1543.     if ( vector & AFF_POISON        ) strcat( buf, " poison"        );
  1544.     if ( vector & AFF_PROTECT       ) strcat( buf, " protect"       );
  1545.     if ( vector & AFF_PARALYSIS     ) strcat( buf, " paralysis"     );
  1546.     if ( vector & AFF_SLEEP         ) strcat( buf, " sleep"         );
  1547.     if ( vector & AFF_SNEAK         ) strcat( buf, " sneak"         );
  1548.     if ( vector & AFF_HIDE          ) strcat( buf, " hide"          );
  1549.     if ( vector & AFF_CHARM         ) strcat( buf, " charm"         );
  1550.     if ( vector & AFF_FLYING        ) strcat( buf, " flying"        );
  1551.     if ( vector & AFF_PASS_DOOR     ) strcat( buf, " pass_door"     );
  1552.     return ( buf[0] != '' ) ? buf+1 : "none";
  1553. }
  1557. /*
  1558.  * Return ascii name of extra flags vector.
  1559.  */
  1560. char *extra_bit_name( int extra_flags )
  1561. {
  1562.     static char buf[512];
  1564.     buf[0] = '';
  1565.     if ( extra_flags & ITEM_GLOW         ) strcat( buf, " glow"         );
  1566.     if ( extra_flags & ITEM_HUM          ) strcat( buf, " hum"          );
  1567.     if ( extra_flags & ITEM_DARK         ) strcat( buf, " dark"         );
  1568.     if ( extra_flags & ITEM_LOCK         ) strcat( buf, " lock"         );
  1569.     if ( extra_flags & ITEM_EVIL         ) strcat( buf, " evil"         );
  1570.     if ( extra_flags & ITEM_INVIS        ) strcat( buf, " invis"        );
  1571.     if ( extra_flags & ITEM_MAGIC        ) strcat( buf, " magic"        );
  1572.     if ( extra_flags & ITEM_NODROP       ) strcat( buf, " nodrop"       );
  1573.     if ( extra_flags & ITEM_BLESS        ) strcat( buf, " bless"        );
  1574.     if ( extra_flags & ITEM_ANTI_GOOD    ) strcat( buf, " anti-good"    );
  1575.     if ( extra_flags & ITEM_ANTI_EVIL    ) strcat( buf, " anti-evil"    );
  1576.     if ( extra_flags & ITEM_ANTI_NEUTRAL ) strcat( buf, " anti-neutral" );
  1577.     if ( extra_flags & ITEM_NOREMOVE     ) strcat( buf, " noremove"     );
  1578.     if ( extra_flags & ITEM_INVENTORY    ) strcat( buf, " inventory"    );
  1579.     if ( extra_flags & 16384    ) strcat( buf, " metallic"    ); // @@@
  1580.     if ( extra_flags & ~(ITEM_GLOW|ITEM_HUM|ITEM_DARK|ITEM_LOCK|ITEM_EVIL|
  1581.           ITEM_INVIS|ITEM_MAGIC|ITEM_NODROP|ITEM_BLESS|ITEM_ANTI_GOOD|
  1582.           ITEM_ANTI_EVIL|ITEM_ANTI_NEUTRAL|ITEM_NOREMOVE|ITEM_INVENTORY|16384))
  1583.        strcat( buf, " (and unknown bits)" ); // @@@
  1584.     return ( buf[0] != '' ) ? buf+1 : "none";
  1585. }