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

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

Internet/网络编程

开发平台：

WINDOWS

ACT_WIZ.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 <stdio.h>
  24. #include <stdlib.h>
  25. #include <string.h>
  26. #include <time.h>
  27. #include "merc.h"
  30. void do_wizhelp( CHAR_DATA *ch, char *argument )
  31. {
  32.     char buf[MAX_STRING_LENGTH];
  33.     char buf1[MAX_STRING_LENGTH];
  34.     int cmd;
  35.     int col;
  36.  
  37.     buf1[0] = '';
  38.     col = 0;
  39.     for ( cmd = 0; cmd_table[cmd].name[0] != ''; cmd++ )
  40.     {
  41.         if ( cmd_table[cmd].level >= LEVEL_HERO
  42.         &&   cmd_table[cmd].level <= get_trust( ch ) )
  43. {
  44.     sprintf( buf, "%-12s", cmd_table[cmd].name );
  45.     strcat( buf1, buf );
  46.     if ( ++col % 6 == 0 )
  47. strcat( buf1, "nr" );
  48. }
  49.     }
  50.  
  51.     if ( col % 6 != 0 )
  52. strcat( buf1, "nr" );
  53.     send_to_char( buf1, ch );
  54.     return;
  55. }
  59. void do_bamfin( CHAR_DATA *ch, char *argument )
  60. {
  61.     if ( !IS_NPC(ch) )
  62.     {
  63. smash_tilde( argument );
  64. free_string( ch->pcdata->bamfin );
  65. ch->pcdata->bamfin = str_dup( argument );
  66. send_to_char( "Ok.nr", ch );
  67.     }
  68.     return;
  69. }
  73. void do_bamfout( CHAR_DATA *ch, char *argument )
  74. {
  75.     if ( !IS_NPC(ch) )
  76.     {
  77. smash_tilde( argument );
  78. free_string( ch->pcdata->bamfout );
  79. ch->pcdata->bamfout = str_dup( argument );
  80. send_to_char( "Ok.nr", ch );
  81.     }
  82.     return;
  83. }
  87. void do_deny( CHAR_DATA *ch, char *argument )
  88. {
  89.     char arg[MAX_INPUT_LENGTH];
  90.     CHAR_DATA *victim;
  92.     one_argument( argument, arg );
  93.     if ( arg[0] == '' )
  94.     {
  95. send_to_char( "Deny whom?nr", ch );
  96. return;
  97.     }
  99.     if ( ( victim = get_char_world( ch, arg ) ) == NULL )
  100.     {
  101. send_to_char( "They aren't here.nr", ch );
  102. return;
  103.     }
  105.     if ( IS_NPC(victim) )
  106.     {
  107. send_to_char( "Not on NPC's.nr", ch );
  108. return;
  109.     }
  111.     if ( get_trust( victim ) >= get_trust( ch ) )
  112.     {
  113. send_to_char( "You failed.nr", ch );
  114. return;
  115.     }
  117.     SET_BIT(victim->act, PLR_DENY);
  118.     send_to_char( "You are denied access!nr", victim );
  119.     send_to_char( "OK.nr", ch );
  120.     do_quit( victim, "" );
  122.     return;
  123. }
  127. void do_disconnect( CHAR_DATA *ch, char *argument )
  128. {
  129.     char arg[MAX_INPUT_LENGTH];
  130.     DESCRIPTOR_DATA *d;
  131.     CHAR_DATA *victim;
  133.     one_argument( argument, arg );
  134.     if ( arg[0] == '' )
  135.     {
  136. send_to_char( "Disconnect whom?nr", ch );
  137. return;
  138.     }
  140.     if ( ( victim = get_char_world( ch, arg ) ) == NULL )
  141.     {
  142. send_to_char( "They aren't here.nr", ch );
  143. return;
  144.     }
  146.     if ( victim->desc == NULL )
  147.     {
  148. act( "$N doesn't have a descriptor.", ch, NULL, victim, TO_CHAR );
  149. return;
  150.     }
  152.     for ( d = descriptor_list; d != NULL; d = d->next )
  153.     {
  154. if ( d == victim->desc )
  155. {
  156.     close_socket( d );
  157.     send_to_char( "Ok.nr", ch );
  158.     return;
  159. }
  160.     }
  162.     bug( "Do_disconnect: desc not found.", 0 );
  163.     send_to_char( "Descriptor not found!nr", ch );
  164.     return;
  165. }
  169. void do_pardon( CHAR_DATA *ch, char *argument )
  170. {
  171.     char arg1[MAX_INPUT_LENGTH];
  172.     char arg2[MAX_INPUT_LENGTH];
  173.     CHAR_DATA *victim;
  175.     argument = one_argument( argument, arg1 );
  176.     argument = one_argument( argument, arg2 );
  178.     if ( arg1[0] == '' || arg2[0] == '' )
  179.     {
  180. send_to_char( "Syntax: pardon <character> <killer|thief>.nr", ch );
  181. return;
  182.     }
  184.     if ( ( victim = get_char_world( ch, arg1 ) ) == NULL )
  185.     {
  186. send_to_char( "They aren't here.nr", ch );
  187. return;
  188.     }
  190.     if ( IS_NPC(victim) )
  191.     {
  192. send_to_char( "Not on NPC's.nr", ch );
  193. return;
  194.     }
  196.     if ( !str_cmp( arg2, "killer" ) )
  197.     {
  198. if ( IS_SET(victim->act, PLR_KILLER) )
  199. {
  200.     REMOVE_BIT( victim->act, PLR_KILLER );
  201.     send_to_char( "Killer flag removed.nr", ch );
  202.     send_to_char( "You are no longer a KILLER.nr", victim );
  203. }
  204. return;
  205.     }
  207.     if ( !str_cmp( arg2, "thief" ) )
  208.     {
  209. if ( IS_SET(victim->act, PLR_THIEF) )
  210. {
  211.     REMOVE_BIT( victim->act, PLR_THIEF );
  212.     send_to_char( "Thief flag removed.nr", ch );
  213.     send_to_char( "You are no longer a THIEF.nr", victim );
  214. }
  215. return;
  216.     }
  218.     send_to_char( "Syntax: pardon <character> <killer|thief>.nr", ch );
  219.     return;
  220. }
  224. void do_echo( CHAR_DATA *ch, char *argument )
  225. {
  226.     DESCRIPTOR_DATA *d;
  227.     
  228.     if ( argument[0] == '' )
  229.     {
  230. send_to_char( "Echo what?nr", ch );
  231. return;
  232.     }
  234.     for ( d = descriptor_list; d; d = d->next )
  235.     {
  236. if ( d->connected == CON_PLAYING )
  237. {
  238.     send_to_char( argument, d->character );
  239.     send_to_char( "nr",   d->character );
  240. }
  241.     }
  243.     return;
  244. }
  248. void do_recho( CHAR_DATA *ch, char *argument )
  249. {
  250.     DESCRIPTOR_DATA *d;
  251.     
  252.     if ( argument[0] == '' )
  253.     {
  254. send_to_char( "Recho what?nr", ch );
  255. return;
  256.     }
  258.     for ( d = descriptor_list; d; d = d->next )
  259.     {
  260. if ( d->connected == CON_PLAYING
  261. &&   d->character->in_room == ch->in_room )
  262. {
  263.     send_to_char( argument, d->character );
  264.     send_to_char( "nr",   d->character );
  265. }
  266.     }
  268.     return;
  269. }
  273. ROOM_INDEX_DATA *find_location( CHAR_DATA *ch, char *arg )
  274. {
  275.     CHAR_DATA *victim;
  276.     OBJ_DATA *obj;
  278.     if ( is_number(arg) )
  279. return get_room_index( atoi( arg ) );
  281.     if ( ( victim = get_char_world( ch, arg ) ) != NULL )
  282. return victim->in_room;
  284.     if ( ( obj = get_obj_world( ch, arg ) ) != NULL )
  285. return obj->in_room;
  287.     return NULL;
  288. }
  292. void do_transfer( CHAR_DATA *ch, char *argument )
  293. {
  294.     char arg1[MAX_INPUT_LENGTH];
  295.     char arg2[MAX_INPUT_LENGTH];
  296.     ROOM_INDEX_DATA *location;
  297.     DESCRIPTOR_DATA *d;
  298.     CHAR_DATA *victim;
  300.     argument = one_argument( argument, arg1 );
  301.     argument = one_argument( argument, arg2 );
  303.     if ( arg1[0] == '' )
  304.     {
  305. send_to_char( "Transfer whom (and where)?nr", ch );
  306. return;
  307.     }
  309.     if ( !str_cmp( arg1, "all" ) )
  310.     {
  311. for ( d = descriptor_list; d != NULL; d = d->next )
  312. {
  313.     if ( d->connected == CON_PLAYING
  314.     &&   d->character != ch
  315.     &&   d->character->in_room != NULL
  316.     &&   can_see( ch, d->character ) )
  317.     {
  318. char buf[MAX_STRING_LENGTH];
  319. sprintf( buf, "%s %s", d->character->name, arg2 );
  320. do_transfer( ch, buf );
  321.     }
  322. }
  323. return;
  324.     }
  326.     /*
  327.      * Thanks to Grodyn for the optional location parameter.
  328.      */
  329.     if ( arg2[0] == '' )
  330.     {
  331. location = ch->in_room;
  332.     }
  333.     else
  334.     {
  335. if ( ( location = find_location( ch, arg2 ) ) == NULL )
  336. {
  337.     send_to_char( "No such location.nr", ch );
  338.     return;
  339. }
  341. if ( room_is_private( location ) )
  342. {
  343.     send_to_char( "That room is private right now.nr", ch );
  344.     return;
  345. }
  346.     }
  348.     if ( ( victim = get_char_world( ch, arg1 ) ) == NULL )
  349.     {
  350. send_to_char( "They aren't here.nr", ch );
  351. return;
  352.     }
  354.     if ( victim->in_room == NULL )
  355.     {
  356. send_to_char( "They are in limbo.nr", ch );
  357. return;
  358.     }
  360.     if ( victim->fighting != NULL )
  361. stop_fighting( victim, TRUE );
  362.     act( "$n disappears in a mushroom cloud.", victim, NULL, NULL, TO_ROOM );
  363.     char_from_room( victim );
  364.     char_to_room( victim, location );
  365.     act( "$n arrives from a puff of smoke.", victim, NULL, NULL, TO_ROOM );
  366.     if ( ch != victim )
  367. act( "$n has transferred you.", ch, NULL, victim, TO_VICT );
  368.     do_look( victim, "auto" );
  369.     send_to_char( "Ok.nr", ch );
  370. }
  374. void do_at( CHAR_DATA *ch, char *argument )
  375. {
  376.     char arg[MAX_INPUT_LENGTH];
  377.     ROOM_INDEX_DATA *location;
  378.     ROOM_INDEX_DATA *original;
  379.     CHAR_DATA *wch;
  380.     
  381.     argument = one_argument( argument, arg );
  383.     if ( arg[0] == '' || argument[0] == '' )
  384.     {
  385. send_to_char( "At where what?nr", ch );
  386. return;
  387.     }
  389.     if ( ( location = find_location( ch, arg ) ) == NULL )
  390.     {
  391. send_to_char( "No such location.nr", ch );
  392. return;
  393.     }
  395.     if ( room_is_private( location ) )
  396.     {
  397. send_to_char( "That room is private right now.nr", ch );
  398. return;
  399.     }
  401.     original = ch->in_room;
  402.     char_from_room( ch );
  403.     char_to_room( ch, location );
  404.     interpret( ch, argument );
  406.     /*
  407.      * See if 'ch' still exists before continuing!
  408.      * Handles 'at XXXX quit' case.
  409.      */
  410.     for ( wch = char_list; wch != NULL; wch = wch->next )
  411.     {
  412. if ( wch == ch )
  413. {
  414.     char_from_room( ch );
  415.     char_to_room( ch, original );
  416.     break;
  417. }
  418.     }
  420.     return;
  421. }
  425. void do_goto( CHAR_DATA *ch, char *argument )
  426. {
  427.     char arg[MAX_INPUT_LENGTH];
  428.     ROOM_INDEX_DATA *location;
  430.     one_argument( argument, arg );
  431.     if ( arg[0] == '' )
  432.     {
  433. send_to_char( "Goto where?nr", ch );
  434. return;
  435.     }
  437.     if ( ( location = find_location( ch, arg ) ) == NULL )
  438.     {
  439. send_to_char( "No such location.nr", ch );
  440. return;
  441.     }
  443.     if ( room_is_private( location ) )
  444.     {
  445. send_to_char( "That room is private right now.nr", ch );
  446. return;
  447.     }
  449.     if ( ch->fighting != NULL )
  450. stop_fighting( ch, TRUE );
  451.     if ( !IS_SET(ch->act, PLR_WIZINVIS) )
  452.     {
  453. act( "$n $T.", ch, NULL,
  454.     (ch->pcdata != NULL && ch->pcdata->bamfout[0] != '')
  455.     ? ch->pcdata->bamfout : "leaves in a swirling mist",  TO_ROOM );
  456.     }
  458.     char_from_room( ch );
  459.     char_to_room( ch, location );
  461.     if ( !IS_SET(ch->act, PLR_WIZINVIS) )
  462.     {
  463. act( "$n $T.", ch, NULL,
  464.     (ch->pcdata != NULL && ch->pcdata->bamfin[0] != '')
  465.     ? ch->pcdata->bamfin : "appears in a swirling mist", TO_ROOM );
  466.     }
  468.     do_look( ch, "auto" );
  469.     return;
  470. }
  474. void do_rstat( CHAR_DATA *ch, char *argument )
  475. {
  476.     char buf[MAX_STRING_LENGTH];
  477.     char buf1[MAX_STRING_LENGTH];
  478.     char arg[MAX_INPUT_LENGTH];
  479.     ROOM_INDEX_DATA *location;
  480.     OBJ_DATA *obj;
  481.     CHAR_DATA *rch;
  482.     int door;
  484.     one_argument( argument, arg );
  485.     location = ( arg[0] == '' ) ? ch->in_room : find_location( ch, arg );
  486.     if ( location == NULL )
  487.     {
  488. send_to_char( "No such location.nr", ch );
  489. return;
  490.     }
  492.     if ( ch->in_room != location && room_is_private( location ) )
  493.     {
  494. send_to_char( "That room is private right now.nr", ch );
  495. return;
  496.     }
  498.     buf1[0] = '';
  500.     sprintf( buf, "Name: '%s.'nrArea: '%s'.nr",
  501. location->name,
  502. location->area->name );
  503.     strcat( buf1, buf );
  505.     sprintf( buf,
  506. "Vnum: %d.  Sector: %d.  Light: %d.nr",
  507. location->vnum,
  508. location->sector_type,
  509. location->light );
  510.     strcat( buf1, buf );
  512.     sprintf( buf,
  513. "Room flags: %d.nrDescription:nr%s",
  514. location->room_flags,
  515. location->description );
  516.     strcat( buf1, buf );
  518.     if ( location->extra_descr != NULL )
  519.     {
  520. EXTRA_DESCR_DATA *ed;
  522. strcat( buf1, "Extra description keywords: '" );
  523. for ( ed = location->extra_descr; ed; ed = ed->next )
  524. {
  525.     strcat( buf1, ed->keyword );
  526.     if ( ed->next != NULL )
  527. strcat( buf1, " " );
  528. }
  529. strcat( buf1, "'.nr" );
  530.     }
  532.     strcat( buf1, "Characters:" );
  533.     for ( rch = location->people; rch; rch = rch->next_in_room )
  534.     {
  535. strcat( buf1, " " );
  536. one_argument( rch->name, buf );
  537. strcat( buf1, buf );
  538.     }
  540.     strcat( buf1, ".nrObjects:   " );
  541.     for ( obj = location->contents; obj; obj = obj->next_content )
  542.     {
  543. strcat( buf1, " " );
  544. one_argument( obj->name, buf );
  545. strcat( buf1, buf );
  546.     }
  547.     strcat( buf1, ".nr" );
  549.     for ( door = 0; door <= 5; door++ )
  550.     {
  551. EXIT_DATA *pexit;
  553. if ( ( pexit = location->exit[door] ) != NULL )
  554. {
  555.     sprintf( buf,
  556. "Door: %d.  To: %d.  Key: %d.  Exit flags: %d.nrKeyword: '%s'.  Description: %s",
  558. door,
  559. pexit->to_room != NULL ? pexit->to_room->vnum : 0,
  560.      pexit->key,
  561.      pexit->exit_info,
  562.      pexit->keyword,
  563.      pexit->description[0] != ''
  564.     ? pexit->description : "(none).nr" );
  565.     strcat( buf1, buf );
  566. }
  567.     }
  569.     send_to_char( buf1, ch );
  570.     return;
  571. }
  575. void do_ostat( CHAR_DATA *ch, char *argument )
  576. {
  577.     char buf[MAX_STRING_LENGTH];
  578.     char buf1[MAX_STRING_LENGTH];
  579.     char arg[MAX_INPUT_LENGTH];
  580.     AFFECT_DATA *paf;
  581.     OBJ_DATA *obj;
  583.     one_argument( argument, arg );
  585.     if ( arg[0] == '' )
  586.     {
  587. send_to_char( "Ostat what?nr", ch );
  588. return;
  589.     }
  591.     buf1[0] = '';
  593.     if ( ( obj = get_obj_world( ch, arg ) ) == NULL )
  594.     {
  595. send_to_char( "Nothing like that in hell, earth, or heaven.nr", ch );
  596. return;
  597.     }
  599.     sprintf( buf, "Name: %s.nr",
  600. obj->name );
  601.     strcat( buf1, buf );
  603.     sprintf( buf, "Vnum: %d.  Type: %s.nr",
  604. obj->pIndexData->vnum, item_type_name( obj ) );
  605.     strcat( buf1, buf );
  607.     sprintf( buf, "Short description: %s.nrLong description: %snr",
  608. obj->short_descr, obj->description );
  609.     strcat( buf1, buf );
  611.     sprintf( buf, "Wear bits: %d.  Extra bits: %s.nr",
  612. obj->wear_flags, extra_bit_name( obj->extra_flags ) );
  613.     strcat( buf1, buf );
  615.     sprintf( buf, "Number: %d/%d.  Weight: %d/%d.nr",
  616. 1,           get_obj_number( obj ),
  617. obj->weight, get_obj_weight( obj ) );
  618.     strcat( buf1, buf );
  620.     sprintf( buf, "Cost: %d.  Timer: %d.  Level: %d.nr",
  621. obj->cost, obj->timer, obj->level );
  622.     strcat( buf1, buf );
  624.     sprintf( buf,
  625. "In room: %d.  In object: %s.  Carried by: %s.  Wear_loc: %d.nr",
  626. obj->in_room    == NULL    ?        0 : obj->in_room->vnum,
  627. obj->in_obj     == NULL    ? "(none)" : obj->in_obj->short_descr,
  628. obj->carried_by == NULL    ? "(none)" : obj->carried_by->name,
  629. obj->wear_loc );
  630.     strcat( buf1, buf );
  631.     
  632.     sprintf( buf, "Values: %d %d %d %d.nr",
  633. obj->value[0], obj->value[1], obj->value[2], obj->value[3] );
  634.     strcat( buf1, buf );
  636.     if ( obj->extra_descr != NULL || obj->pIndexData->extra_descr != NULL )
  637.     {
  638. EXTRA_DESCR_DATA *ed;
  640. strcat( buf1, "Extra description keywords: '" );
  642. for ( ed = obj->extra_descr; ed != NULL; ed = ed->next )
  643. {
  644.     strcat( buf1, ed->keyword );
  645.     if ( ed->next != NULL )
  646. strcat( buf1, " " );
  647. }
  649. for ( ed = obj->pIndexData->extra_descr; ed != NULL; ed = ed->next )
  650. {
  651.     strcat( buf1, ed->keyword );
  652.     if ( ed->next != NULL )
  653. strcat( buf1, " " );
  654. }
  656. strcat( buf1, "'.nr" );
  657.     }
  659.     for ( paf = obj->affected; paf != NULL; paf = paf->next )
  660.     {
  661. sprintf( buf, "Affects %s by %d.nr",
  662.     affect_loc_name( paf->location ), paf->modifier );
  663. strcat( buf1, buf );
  664.     }
  666.     for ( paf = obj->pIndexData->affected; paf != NULL; paf = paf->next )
  667.     {
  668. sprintf( buf, "Affects %s by %d.nr",
  669.     affect_loc_name( paf->location ), paf->modifier );
  670. strcat( buf1, buf );
  671.     }
  673.     send_to_char( buf1, ch );
  674.     return;
  675. }
  677. /*
  678.  * Return ascii name of an act bit vector.
  679.  */
  680. char *act_bit_name( int vector )
  681. {
  682.     static char buf[512];
  684.     buf[0] = '';
  685.     if ( vector & ACT_IS_NPC    ) strcat( buf, " npc"           );
  686.     if ( vector & ACT_SENTINEL ) strcat( buf, " sentinel"      );
  687.     if ( vector & ACT_SCAVENGER ) strcat( buf, " scavenger"     );
  688.     if ( vector & ACT_AGGRESSIVE ) strcat( buf, " aggressive"    );
  689.     if ( vector & ACT_STAY_AREA ) strcat( buf, " stay-area"     );
  690.     if ( vector & ACT_WIMPY    ) strcat( buf, " wimpy"         );
  691.     if ( vector & ACT_PET    ) strcat( buf, " pet"           );
  692.     if ( vector & ACT_TRAIN    ) strcat( buf, " train"         );
  693.     if ( vector & ACT_PRACTICE ) strcat( buf, " practice"      );
  694.     return buf+1;
  695. }
  697. void do_mstat( CHAR_DATA *ch, char *argument )
  698. {
  699.     char buf[MAX_STRING_LENGTH];
  700.     char buf1[MAX_STRING_LENGTH];
  701.     char arg[MAX_INPUT_LENGTH];
  702.     AFFECT_DATA *paf;
  703.     CHAR_DATA *victim;
  705.     one_argument( argument, arg );
  707.     if ( arg[0] == '' )
  708.     {
  709. send_to_char( "Mstat whom?nr", ch );
  710. return;
  711.     }
  713.     if ( ( victim = get_char_world( ch, arg ) ) == NULL )
  714.     {
  715. send_to_char( "They aren't here.nr", ch );
  716. return;
  717.     }
  719.     buf1[0] = '';
  721.     sprintf( buf, "Name: %s.nr",
  722. victim->name );
  723.     strcat( buf1, buf );
  725.     sprintf( buf, "Vnum: %d.  Sex: %s.  Room: %d.nr",
  726. IS_NPC(victim) ? victim->pIndexData->vnum : 0,
  727. victim->sex == SEX_MALE    ? "male"   :
  728. victim->sex == SEX_FEMALE  ? "female" : "neutral",
  729. victim->in_room == NULL    ?        0 : victim->in_room->vnum
  730. );
  731.     strcat( buf1, buf );
  733.     sprintf( buf, "Str: %d.  Int: %d.  Wis: %d.  Dex: %d.  Con: %d.nr",
  734. get_curr_str(victim),
  735. get_curr_int(victim),
  736. get_curr_wis(victim),
  737. get_curr_dex(victim),
  738. get_curr_con(victim) );
  739.     strcat( buf1, buf );
  741.     sprintf( buf, "Hp: %d/%d.  Mana: %d/%d.  Move: %d/%d.  Practices: %d.nr",
  742. victim->hit,         victim->max_hit,
  743. victim->mana,        victim->max_mana,
  744. victim->move,        victim->max_move,
  745. victim->practice );
  746.     strcat( buf1, buf );
  748.     sprintf( buf,
  749. "Lv: %d.  Class: %d.  Align: %d.  AC: %d.  Gold: %d.  Exp: %d.nr",
  750. victim->level,       victim->class,        victim->alignment,
  751. GET_AC(victim),      victim->gold,         victim->exp );
  752.     strcat( buf1, buf );
  754.     sprintf( buf, "Hitroll: %d.  Damroll: %d.  Position: %d.  Wimpy: %d.nr",
  755. GET_HITROLL(victim), GET_DAMROLL(victim),
  756. victim->position,    victim->wimpy );
  757.     strcat( buf1, buf );
  759.     if ( !IS_NPC( victim ) )
  760.     {
  761. sprintf( buf, "Page Lines: %d.nr", victim->pcdata->pagelen );
  762. strcat( buf1, buf );
  763.     }
  765.     sprintf( buf, "Fighting: %s.nr",
  766.     victim->fighting ? victim->fighting->name : "(none)" );
  767.     strcat( buf1, buf );
  769.     if ( !IS_NPC(victim) )
  770.     {
  771. sprintf( buf,
  772.     "Thirst: %d.  Full: %d.  Drunk: %d.  Saving throw: %d.nr",
  773.     victim->pcdata->condition[COND_THIRST],
  774.     victim->pcdata->condition[COND_FULL],
  775.     victim->pcdata->condition[COND_DRUNK],
  776.     victim->saving_throw );
  777. strcat( buf1, buf );
  778.     }
  780.     sprintf( buf, "Carry number: %d.  Carry weight: %d.nr",
  781. victim->carry_number, victim->carry_weight );
  782.     strcat( buf1, buf );
  784.     sprintf( buf, "Age: %d.  Played: %d.  Timer: %d.  Act: %s.nr",
  785.    get_age( victim ), (int) victim->played, victim->timer,
  786.    act_bit_name(victim->act) );
  787.     strcat( buf1, buf );
  789.     sprintf( buf, "Master: %s.  Leader: %s.  Affected by: %s.nr",
  790. victim->master      ? victim->master->name   : "(none)",
  791. victim->leader      ? victim->leader->name   : "(none)",
  792. affect_bit_name( victim->affected_by ) );
  793.     strcat( buf1, buf );
  795.     sprintf( buf, "Short description: %s.nrLong  description: %s",
  796. victim->short_descr,
  797. victim->long_descr[0] != '' ? victim->long_descr : "(none).nr" );
  798.     strcat( buf1, buf );
  800.     if ( IS_NPC(victim) && victim->spec_fun != 0 )
  801. strcat( buf1, "Mobile has spec fun.nr" );
  803.     for ( paf = victim->affected; paf != NULL; paf = paf->next )
  804.     {
  805. sprintf( buf,
  806.     "Spell: '%s' modifies %s by %d for %d hours with bits %s.nr",
  807.     skill_table[(int) paf->type].name,
  808.     affect_loc_name( paf->location ),
  809.     paf->modifier,
  810.     paf->duration,
  811.     affect_bit_name( paf->bitvector )
  812.     );
  813. strcat( buf1, buf );
  814.     }
  816.     send_to_char( buf1, ch );
  817.     return;
  818. }
  822. void do_mfind( CHAR_DATA *ch, char *argument )
  823. {
  824.     extern int top_mob_index;
  825.     char buf[2*MAX_STRING_LENGTH];
  826.     char buf1[2*MAX_STRING_LENGTH];
  827.     char arg[MAX_INPUT_LENGTH];
  828.     MOB_INDEX_DATA *pMobIndex;
  829.     int vnum;
  830.     int nMatch;
  831.     bool fAll;
  832.     bool found;
  834.     one_argument( argument, arg );
  835.     if ( arg[0] == '' )
  836.     {
  837. send_to_char( "Mfind whom?nr", ch );
  838. return;
  839.     }
  841.     buf1[0] = '';
  842.     fAll = !str_cmp( arg, "all" );
  843.     found = FALSE;
  844.     nMatch = 0;
  846.     /*
  847.      * Yeah, so iterating over all vnum's takes 10,000 loops.
  848.      * Get_mob_index is fast, and I don't feel like threading another link.
  849.      * Do you?
  850.      * -- Furey
  851.      */
  852.     for ( vnum = 0; nMatch < top_mob_index; vnum++ )
  853.     {
  854. if ( ( pMobIndex = get_mob_index( vnum ) ) != NULL )
  855. {
  856.     nMatch++;
  857.     if ( fAll || is_name( arg, pMobIndex->player_name ) )
  858.     {
  859. found = TRUE;
  860. sprintf( buf, "[%5d] %snr",
  861.     pMobIndex->vnum, capitalize( pMobIndex->short_descr ) );
  862.                 if (!fAll)
  863.                     strcat( buf1, buf );
  864.                 else
  865.                     send_to_char( buf, ch ); 
  866.     }
  867. }
  868.     }
  870.     if ( !found )
  871.     {
  872. send_to_char( "Nothing like that in hell, earth, or heaven.nr", ch );
  873. return;
  874.     }
  876.     if(!fAll)
  877.        send_to_char( buf1, ch );
  878.     return;
  879. }
  883. void do_ofind( CHAR_DATA *ch, char *argument )
  884. {
  885.     extern int top_obj_index;
  886.     char buf[2*MAX_STRING_LENGTH];
  887.     char buf1[2*MAX_STRING_LENGTH];
  888.     char arg[MAX_INPUT_LENGTH];
  889.     OBJ_INDEX_DATA *pObjIndex;
  890.     int vnum;
  891.     int nMatch;
  892.     bool fAll;
  893.     bool found;
  895.     one_argument( argument, arg );
  896.     if ( arg[0] == '' )
  897.     {
  898. send_to_char( "Ofind what?nr", ch );
  899. return;
  900.     }
  902.     buf1[0] = '';
  903.     fAll = !str_cmp( arg, "all" );
  904.     found = FALSE;
  905.     nMatch = 0;
  907.     /*
  908.      * Yeah, so iterating over all vnum's takes 10,000 loops.
  909.      * Get_obj_index is fast, and I don't feel like threading another link.
  910.      * Do you?
  911.      * -- Furey
  912.      */
  913.     for ( vnum = 0; nMatch < top_obj_index; vnum++ )
  914.     {
  915. if ( ( pObjIndex = get_obj_index( vnum ) ) != NULL )
  916. {
  917.     nMatch++;
  918.     if ( fAll || is_name( arg, pObjIndex->name ) )
  919.     {
  920. found = TRUE;
  921. sprintf( buf, "[%5d] %snr",
  922.     pObjIndex->vnum, capitalize( pObjIndex->short_descr ) );
  923.                     if (!fAll)
  924.                         strcat( buf1, buf );
  925.                     else
  926.                         send_to_char( buf, ch ); 
  927. // strcat( buf1, buf );
  928.     }
  929. }
  930.     }
  932.     if ( !found )
  933.     {
  934. send_to_char( "Nothing like that in hell, earth, or heaven.nr", ch );
  935. return;
  936.     }
  938.     if(!fAll)
  939.        send_to_char( buf1, ch );
  940.     return;
  941. }
  944. void do_mwhere( CHAR_DATA *ch, char *argument )
  945. {
  946.     char buf[MAX_STRING_LENGTH];
  947.     char arg[MAX_INPUT_LENGTH];
  948.     CHAR_DATA *victim;
  949.     bool found;
  951.     one_argument( argument, arg );
  952.     if ( arg[0] == '' )
  953.     {
  954. send_to_char( "Mwhere whom?nr", ch );
  955. return;
  956.     }
  958.     found = FALSE;
  959.     for ( victim = char_list; victim != NULL; victim = victim->next )
  960.     {
  961. if ( IS_NPC(victim)
  962. &&   victim->in_room != NULL
  963. &&   is_name( arg, victim->name ) )
  964. {
  965.     found = TRUE;
  966.     sprintf( buf, "[%5d] %-28s [%5d] %snr",
  967. victim->pIndexData->vnum,
  968. victim->short_descr,
  969. victim->in_room->vnum,
  970. victim->in_room->name );
  971.     send_to_char(buf, ch);
  972. }
  973.     }
  975.     if ( !found )
  976.     {
  977. act( "You didn't find any $T.", ch, NULL, arg, TO_CHAR );
  978. return;
  979.     }
  981.     return;
  982. }
  984. // @@@
  985. void do_shoplist( CHAR_DATA *ch, char *argument )
  986. {
  987.     SHOP_DATA *pShop;
  988.     char buf[32768];
  989.     char buf1[MAX_STRING_LENGTH];
  991.     buf[0] = '';
  992.     for (pShop = shop_first; pShop; pShop = pShop->next)
  993.        {
  994.        sprintf(buf1, "%-20s opens at %2d closes at %2d buy %4d%% sell %4d%%nr",
  995.           get_mob_index( pShop->keeper )->short_descr, pShop->open_hour,
  996.           pShop->close_hour, pShop->profit_buy, pShop->profit_sell);
  997.        strcat( buf, buf1 );
  998.        }
  1000.     send_to_char(buf, ch);
  1001. }
  1003. // @@@
  1004. void do_orphans( CHAR_DATA *ch, char *argument )
  1005. {
  1006.     char buf[MAX_INPUT_LENGTH];
  1007.     char buf1[32768]; // @@@ This is the limit to the response length...
  1008.     OBJ_DATA *obj;
  1009.     OBJ_DATA *in_obj;
  1010.     bool found;
  1012.     buf1[0] = ''; // @@@
  1013.     found = FALSE;
  1014.     for ( obj = object_list; obj != NULL; obj = obj->next )
  1015.     {
  1016. for ( in_obj = obj; in_obj->in_obj != NULL; in_obj = in_obj->in_obj )
  1017.     ;
  1019. if ( in_obj->carried_by == NULL  && in_obj->in_room == NULL)
  1020. {
  1021.             found = TRUE;
  1022.     sprintf( buf, "%snr", obj->short_descr );
  1023.             buf[0] = UPPER(buf[0]);
  1024.             if (strlen(buf1) + strlen(buf) >= sizeof buf1 - 2) // @@@
  1025.                break;
  1026.             strcat(buf1, buf); // @@@
  1027. }
  1029.     }
  1031.     if ( !found )
  1032. send_to_char( "Nothing like that in hell, earth, or heaven.nr", ch );
  1033.     else // @@@
  1034.         send_to_char( buf1, ch ); // @@@
  1035.     return;
  1036. }
  1038. void do_reboo( CHAR_DATA *ch, char *argument )
  1039. {
  1040.     send_to_char( "If you want to REBOOT, spell it out.nr", ch );
  1041.     return;
  1042. }
  1046. void do_reboot( CHAR_DATA *ch, char *argument )
  1047. {
  1048.     char buf[MAX_STRING_LENGTH];
  1049.     extern bool merc_down;
  1051.     sprintf( buf, "Reboot by %s.", ch->name );
  1052.     do_echo( ch, buf );
  1053.     merc_down = TRUE;
  1054.     return;
  1055. }
  1059. void do_shutdow( CHAR_DATA *ch, char *argument )
  1060. {
  1061.     send_to_char( "If you want to SHUTDOWN, spell it out.nr", ch );
  1062.     return;
  1063. }
  1067. void do_shutdown( CHAR_DATA *ch, char *argument )
  1068. {
  1069.     char buf[MAX_STRING_LENGTH];
  1070.     extern bool merc_down;
  1072.     sprintf( buf, "Shutdown by %s.", ch->name );
  1073.     append_file( ch, SHUTDOWN_FILE, buf );
  1074.     strcat( buf, "nr" );
  1075.     do_echo( ch, buf );
  1076.     merc_down = TRUE;
  1077.     return;
  1078. }
  1082. void do_snoop( CHAR_DATA *ch, char *argument )
  1083. {
  1084.     char arg[MAX_INPUT_LENGTH];
  1085.     DESCRIPTOR_DATA *d;
  1086.     CHAR_DATA *victim;
  1088.     one_argument( argument, arg );
  1090.     if ( arg[0] == '' )
  1091.     {
  1092. send_to_char( "Snoop whom?nr", ch );
  1093. return;
  1094.     }
  1096.     if ( ( victim = get_char_world( ch, arg ) ) == NULL )
  1097.     {
  1098. send_to_char( "They aren't here.nr", ch );
  1099. return;
  1100.     }
  1102.     if ( victim->desc == NULL )
  1103.     {
  1104. send_to_char( "No descriptor to snoop.nr", ch );
  1105. return;
  1106.     }
  1108.     if ( victim == ch )
  1109.     {
  1110. send_to_char( "Cancelling all snoops.nr", ch );
  1111. for ( d = descriptor_list; d != NULL; d = d->next )
  1112. {
  1113.     if ( d->snoop_by == ch->desc )
  1114. d->snoop_by = NULL;
  1115. }
  1116. return;
  1117.     }
  1119.     if ( victim->desc->snoop_by != NULL )
  1120.     {
  1121. send_to_char( "Busy already.nr", ch );
  1122. return;
  1123.     }
  1125.     if ( get_trust( victim ) >= get_trust( ch ) )
  1126.     {
  1127. send_to_char( "You failed.nr", ch );
  1128. return;
  1129.     }
  1131.     if ( ch->desc != NULL )
  1132.     {
  1133. for ( d = ch->desc->snoop_by; d != NULL; d = d->snoop_by )
  1134. {
  1135.     if ( d->character == victim || d->original == victim )
  1136.     {
  1137. send_to_char( "No snoop loops.nr", ch );
  1138. return;
  1139.     }
  1140. }
  1141.     }
  1143.     victim->desc->snoop_by = ch->desc;
  1144.     send_to_char( "Ok.nr", ch );
  1145.     return;
  1146. }
  1150. void do_switch( CHAR_DATA *ch, char *argument )
  1151. {
  1152.     char arg[MAX_INPUT_LENGTH];
  1153.     CHAR_DATA *victim;
  1155.     one_argument( argument, arg );
  1156.     
  1157.     if ( arg[0] == '' )
  1158.     {
  1159. send_to_char( "Switch into whom?nr", ch );
  1160. return;
  1161.     }
  1163.     if ( ch->desc == NULL )
  1164. return;
  1165.     
  1166.     if ( ch->desc->original != NULL )
  1167.     {
  1168. send_to_char( "You are already switched.nr", ch );
  1169. return;
  1170.     }
  1172.     if ( ( victim = get_char_world( ch, arg ) ) == NULL )
  1173.     {
  1174. send_to_char( "They aren't here.nr", ch );
  1175. return;
  1176.     }
  1178.     if ( victim == ch )
  1179.     {
  1180. send_to_char( "Ok.nr", ch );
  1181. return;
  1182.     }
  1184.     /*
  1185.      * Pointed out by Da Pub (What Mud)
  1186.      */
  1187.     if ( !IS_NPC( victim ) )
  1188.     {
  1189.         send_to_char( "You cannot switch into a player!nr", ch );
  1190. return;
  1191.     }
  1193.     if ( victim->desc != NULL )
  1194.     {
  1195. send_to_char( "Character in use.nr", ch );
  1196. return;
  1197.     }
  1199.     ch->desc->character = victim;
  1200.     ch->desc->original  = ch;
  1201.     victim->desc        = ch->desc;
  1202.     ch->desc            = NULL;
  1203.     send_to_char( "Ok.nr", victim );
  1204.     return;
  1205. }
  1209. void do_return( CHAR_DATA *ch, char *argument )
  1210. {
  1211.     if ( ch->desc == NULL )
  1212. return;
  1214.     if ( ch->desc->original == NULL )
  1215.     {
  1216. send_to_char( "You aren't switched.nr", ch );
  1217. return;
  1218.     }
  1220.     send_to_char( "You return to your original body.nr", ch );
  1221.     ch->desc->character       = ch->desc->original;
  1222.     ch->desc->original        = NULL;
  1223.     ch->desc->character->desc = ch->desc; 
  1224.     ch->desc                  = NULL;
  1225.     return;
  1226. }
  1230. void do_mload( CHAR_DATA *ch, char *argument )
  1231. {
  1232.     char arg[MAX_INPUT_LENGTH];
  1233.     MOB_INDEX_DATA *pMobIndex;
  1234.     CHAR_DATA *victim;
  1235.     
  1236.     one_argument( argument, arg );
  1238.     if ( arg[0] == '' || !is_number(arg) )
  1239.     {
  1240. send_to_char( "Syntax: mload <vnum>.nr", ch );
  1241. return;
  1242.     }
  1244.     if ( ( pMobIndex = get_mob_index( atoi( arg ) ) ) == NULL )
  1245.     {
  1246. send_to_char( "No mob has that vnum.nr", ch );
  1247. return;
  1248.     }
  1250.     victim = create_mobile( pMobIndex );
  1251.     char_to_room( victim, ch->in_room );
  1252.     act( "$n has created $N!", ch, NULL, victim, TO_ROOM );
  1253.     send_to_char( "Ok.nr", ch );
  1254.     return;
  1255. }
  1259. void do_oload( CHAR_DATA *ch, char *argument )
  1260. {
  1261.     char arg1[MAX_INPUT_LENGTH];
  1262.     char arg2[MAX_INPUT_LENGTH];
  1263.     OBJ_INDEX_DATA *pObjIndex;
  1264.     OBJ_DATA *obj;
  1265.     int level;
  1266.  
  1267.     argument = one_argument( argument, arg1 );
  1268.     argument = one_argument( argument, arg2 );
  1269.  
  1270.     if ( arg1[0] == '' || !is_number( arg1 ) )
  1271.     {
  1272.         send_to_char( "Syntax: oload <vnum> <level>.nr", ch );
  1273.         return;
  1274.     }
  1275.  
  1276.     if ( arg2[0] == '' )
  1277.     {
  1278. level = get_trust( ch );
  1279.     }
  1280.     else
  1281.     {
  1282. /*
  1283.  * New feature from Alander.
  1284.  */
  1285.         if ( !is_number( arg2 ) )
  1286.         {
  1287.     send_to_char( "Syntax: oload <vnum> <level>.nr", ch );
  1288.     return;
  1289.         }
  1290.         level = atoi( arg2 );
  1291. if ( level < 0 || level > get_trust( ch ) )
  1292.         {
  1293.     send_to_char( "Limited to your trust level.nr", ch );
  1294.     return;
  1295.         }
  1296.     }
  1298.     if ( ( pObjIndex = get_obj_index( atoi( arg1 ) ) ) == NULL )
  1299.     {
  1300. send_to_char( "No object has that vnum.nr", ch );
  1301. return;
  1302.     }
  1304.     obj = create_object( pObjIndex, level );
  1305.     if ( CAN_WEAR(obj, ITEM_TAKE) )
  1306.     {
  1307. obj_to_char( obj, ch );
  1308.     }
  1309.     else
  1310.     {
  1311. obj_to_room( obj, ch->in_room );
  1312. act( "$n has created $p!", ch, obj, NULL, TO_ROOM );
  1313.     }
  1314.     send_to_char( "Ok.nr", ch );
  1315.     return;
  1316. }
  1320. void do_purge( CHAR_DATA *ch, char *argument )
  1321. {
  1322.     char arg[MAX_INPUT_LENGTH];
  1323.     CHAR_DATA *victim;
  1324.     OBJ_DATA *obj;
  1326.     one_argument( argument, arg );
  1328.     if ( arg[0] == '' )
  1329.     {
  1330. /* 'purge' */
  1331. CHAR_DATA *vnext;
  1332. OBJ_DATA  *obj_next;
  1334. for ( victim = ch->in_room->people; victim != NULL; victim = vnext )
  1335. {
  1336.     vnext = victim->next_in_room;
  1337.     if ( IS_NPC(victim) && victim != ch )
  1338. extract_char( victim, TRUE );
  1339. }
  1341. for ( obj = ch->in_room->contents; obj != NULL; obj = obj_next )
  1342. {
  1343.     obj_next = obj->next_content;
  1344.     extract_obj( obj );
  1345. }
  1347. act( "$n purges the room!", ch, NULL, NULL, TO_ROOM);
  1348. send_to_char( "Ok.nr", ch );
  1349. return;
  1350.     }
  1352.     if ( ( victim = get_char_world( ch, arg ) ) == NULL )
  1353.     {
  1354. send_to_char( "They aren't here.nr", ch );
  1355. return;
  1356.     }
  1358.     if ( !IS_NPC(victim) )
  1359.     {
  1360. send_to_char( "Not on PC's.nr", ch );
  1361. return;
  1362.     }
  1364.     act( "$n purges $N.", ch, NULL, victim, TO_NOTVICT );
  1365.     extract_char( victim, TRUE );
  1366.     return;
  1367. }
  1371. void do_advance( CHAR_DATA *ch, char *argument )
  1372. {
  1373.     char arg1[MAX_INPUT_LENGTH];
  1374.     char arg2[MAX_INPUT_LENGTH];
  1375.     CHAR_DATA *victim;
  1376.     int level;
  1377.     int iLevel;
  1379.     argument = one_argument( argument, arg1 );
  1380.     argument = one_argument( argument, arg2 );
  1382.     if ( arg1[0] == '' || arg2[0] == '' || !is_number( arg2 ) )
  1383.     {
  1384. send_to_char( "Syntax: advance <char> <level>.nr", ch );
  1385. return;
  1386.     }
  1388.     if ( ( victim = get_char_room( ch, arg1 ) ) == NULL )
  1389.     {
  1390. send_to_char( "That player is not here.nr", ch);
  1391. return;
  1392.     }
  1394.     if ( IS_NPC(victim) )
  1395.     {
  1396. send_to_char( "Not on NPC's.nr", ch );
  1397. return;
  1398.     }
  1400.     if ( ( level = atoi( arg2 ) ) < 1 || level > 40 )
  1401.     {
  1402. send_to_char( "Level must be 1 to 40.nr", ch );
  1403. return;
  1404.     }
  1406.     if ( level > get_trust( ch ) )
  1407.     {
  1408. send_to_char( "Limited to your trust level.nr", ch );
  1409. return;
  1410.     }
  1412.     /*
  1413.      * Lower level:
  1414.      *   Reset to level 1.
  1415.      *   Then raise again.
  1416.      *   Currently, an imp can lower another imp.
  1417.      *   -- Swiftest
  1418.      */
  1419.     if ( level <= victim->level )
  1420.     {
  1421. int sn;
  1423. send_to_char( "Lowering a player's level!nr", ch );
  1424. send_to_char( "**** OOOOHHHHHHHHHH  NNNNOOOO ****nr", victim );
  1425. victim->level    = 1;
  1426. victim->exp      = 1000;
  1427. victim->max_hit  = 10;
  1428. victim->max_mana = 100;
  1429. victim->max_move = 100;
  1430. for ( sn = 0; sn < MAX_SKILL; sn++ )
  1431.     victim->pcdata->learned[sn] = 0;
  1432. victim->practice = 0;
  1433. victim->hit      = victim->max_hit;
  1434. victim->mana     = victim->max_mana;
  1435. victim->move     = victim->max_move;
  1436. advance_level( victim );
  1437.     }
  1438.     else
  1439.     {
  1440. send_to_char( "Raising a player's level!nr", ch );
  1441. send_to_char( "**** OOOOHHHHHHHHHH  YYYYEEEESSS ****nr", victim );
  1442.     }
  1444.     for ( iLevel = victim->level ; iLevel < level; iLevel++ )
  1445.     {
  1446. send_to_char( "You raise a level!!  ", victim );
  1447. victim->level += 1;
  1448. advance_level( victim );
  1449.     }
  1450.     victim->exp   = 1000 * UMAX( 1, victim->level );
  1451.     victim->trust = 0;
  1452.     return;
  1453. }
  1457. void do_trust( CHAR_DATA *ch, char *argument )
  1458. {
  1459.     char arg1[MAX_INPUT_LENGTH];
  1460.     char arg2[MAX_INPUT_LENGTH];
  1461.     CHAR_DATA *victim;
  1462.     int level;
  1464.     argument = one_argument( argument, arg1 );
  1465.     argument = one_argument( argument, arg2 );
  1467.     if ( arg1[0] == '' || arg2[0] == '' || !is_number( arg2 ) )
  1468.     {
  1469. send_to_char( "Syntax: trust <char> <level>.nr", ch );
  1470. return;
  1471.     }
  1473.     if ( ( victim = get_char_room( ch, arg1 ) ) == NULL )
  1474.     {
  1475. send_to_char( "That player is not here.nr", ch);
  1476. return;
  1477.     }
  1479.     if ( ( level = atoi( arg2 ) ) < 0 || level > 40 )
  1480.     {
  1481. send_to_char( "Level must be 0 (reset) or 1 to 40.nr", ch );
  1482. return;
  1483.     }
  1485.     if ( level > get_trust( ch ) )
  1486.     {
  1487. send_to_char( "Limited to your trust.nr", ch );
  1488. return;
  1489.     }
  1491.     victim->trust = level;
  1492.     return;
  1493. }
  1497. void do_restore( CHAR_DATA *ch, char *argument )
  1498. {
  1499.     char arg[MAX_INPUT_LENGTH];
  1500.     CHAR_DATA *victim;
  1502.     one_argument( argument, arg );
  1503.     if ( arg[0] == '' )
  1504.     {
  1505. send_to_char( "Restore whom?nr", ch );
  1506. return;
  1507.     }
  1509.     if ( !str_cmp( arg, "all" ) )
  1510.       {
  1511.     
  1512.         for ( victim = char_list; victim != NULL; victim = victim->next )
  1513.          
  1514.           {
  1515.             if ( !IS_NPC(victim) )
  1516.               {
  1517.                victim->hit  = victim->max_hit;
  1518.                victim->mana = victim->max_mana;
  1519.                victim->move = victim->max_move;
  1520.                update_pos( victim );
  1521.                act( "$n has restored you.", ch, NULL, victim, TO_VICT );
  1522.              }      
  1523.           }
  1524.        send_to_char( "Ok.nr", ch );
  1525.        return;     
  1526.       }
  1528.     if ( ( victim = get_char_world( ch, arg ) ) == NULL )
  1529.     {
  1530. send_to_char( "They aren't here.nr", ch );
  1531. return;
  1532.     }
  1534.     victim->hit  = victim->max_hit;
  1535.     victim->mana = victim->max_mana;
  1536.     victim->move = victim->max_move;
  1537.     update_pos( victim );
  1538.     act( "$n has restored you.", ch, NULL, victim, TO_VICT );
  1539.     send_to_char( "Ok.nr", ch );
  1540.     return;
  1541. }
  1545. void do_freeze( CHAR_DATA *ch, char *argument )
  1546. {
  1547.     char arg[MAX_INPUT_LENGTH];
  1548.     CHAR_DATA *victim;
  1550.     one_argument( argument, arg );
  1552.     if ( arg[0] == '' )
  1553.     {
  1554. send_to_char( "Freeze whom?nr", ch );
  1555. return;
  1556.     }
  1558.     if ( ( victim = get_char_world( ch, arg ) ) == NULL )
  1559.     {
  1560. send_to_char( "They aren't here.nr", ch );
  1561. return;
  1562.     }
  1564.     if ( IS_NPC(victim) )
  1565.     {
  1566. send_to_char( "Not on NPC's.nr", ch );
  1567. return;
  1568.     }
  1570.     if ( get_trust( victim ) >= get_trust( ch ) )
  1571.     {
  1572. send_to_char( "You failed.nr", ch );
  1573. return;
  1574.     }
  1576.     if ( IS_SET(victim->act, PLR_FREEZE) )
  1577.     {
  1578. REMOVE_BIT(victim->act, PLR_FREEZE);
  1579. send_to_char( "You can play again.nr", victim );
  1580. send_to_char( "FREEZE removed.nr", ch );
  1581.     }
  1582.     else
  1583.     {
  1584. SET_BIT(victim->act, PLR_FREEZE);
  1585. send_to_char( "You can't do ANYthing!nr", victim );
  1586. send_to_char( "FREEZE set.nr", ch );
  1587.     }
  1589.     save_char_obj( victim );
  1591.     return;
  1592. }
  1596. void do_log( CHAR_DATA *ch, char *argument )
  1597. {
  1598.     char arg[MAX_INPUT_LENGTH];
  1599.     CHAR_DATA *victim;
  1601.     one_argument( argument, arg );
  1603.     if ( arg[0] == '' )
  1604.     {
  1605. send_to_char( "Log whom?nr", ch );
  1606. return;
  1607.     }
  1609.     if ( !str_cmp( arg, "all" ) )
  1610.     {
  1611. if ( fLogAll )
  1612. {
  1613.     fLogAll = FALSE;
  1614.     send_to_char( "Log ALL off.nr", ch );
  1615. }
  1616. else
  1617. {
  1618.     fLogAll = TRUE;
  1619.     send_to_char( "Log ALL on.nr", ch );
  1620. }
  1621. return;
  1622.     }
  1624.     if ( ( victim = get_char_world( ch, arg ) ) == NULL )
  1625.     {
  1626. send_to_char( "They aren't here.nr", ch );
  1627. return;
  1628.     }
  1630.     if ( IS_NPC(victim) )
  1631.     {
  1632. send_to_char( "Not on NPC's.nr", ch );
  1633. return;
  1634.     }
  1636.     /*
  1637.      * No level check, gods can log anyone.
  1638.      */
  1639.     if ( IS_SET(victim->act, PLR_LOG) )
  1640.     {
  1641. REMOVE_BIT(victim->act, PLR_LOG);
  1642. send_to_char( "LOG removed.nr", ch );
  1643.     }
  1644.     else
  1645.     {
  1646. SET_BIT(victim->act, PLR_LOG);
  1647. send_to_char( "LOG set.nr", ch );
  1648.     }
  1650.     return;
  1651. }
  1655. void do_noemote( CHAR_DATA *ch, char *argument )
  1656. {
  1657.     char arg[MAX_INPUT_LENGTH];
  1658.     CHAR_DATA *victim;
  1660.     one_argument( argument, arg );
  1662.     if ( arg[0] == '' )
  1663.     {
  1664. send_to_char( "Noemote whom?nr", ch );
  1665. return;
  1666.     }
  1668.     if ( ( victim = get_char_world( ch, arg ) ) == NULL )
  1669.     {
  1670. send_to_char( "They aren't here.nr", ch );
  1671. return;
  1672.     }
  1674.     if ( IS_NPC(victim) )
  1675.     {
  1676. send_to_char( "Not on NPC's.nr", ch );
  1677. return;
  1678.     }
  1680.     if ( get_trust( victim ) >= get_trust( ch ) )
  1681.     {
  1682. send_to_char( "You failed.nr", ch );
  1683. return;
  1684.     }
  1686.     if ( IS_SET(victim->act, PLR_NO_EMOTE) )
  1687.     {
  1688. REMOVE_BIT(victim->act, PLR_NO_EMOTE);
  1689. send_to_char( "You can emote again.nr", victim );
  1690. send_to_char( "NO_EMOTE removed.nr", ch );
  1691.     }
  1692.     else
  1693.     {
  1694. SET_BIT(victim->act, PLR_NO_EMOTE);
  1695. send_to_char( "You can't emote!nr", victim );
  1696. send_to_char( "NO_EMOTE set.nr", ch );
  1697.     }
  1699.     return;
  1700. }
  1704. void do_notell( CHAR_DATA *ch, char *argument )
  1705. {
  1706.     char arg[MAX_INPUT_LENGTH];
  1707.     CHAR_DATA *victim;
  1709.     one_argument( argument, arg );
  1711.     if ( arg[0] == '' )
  1712.     {
  1713. send_to_char( "Notell whom?", ch );
  1714. return;
  1715.     }
  1717.     if ( ( victim = get_char_world( ch, arg ) ) == NULL )
  1718.     {
  1719. send_to_char( "They aren't here.nr", ch );
  1720. return;
  1721.     }
  1723.     if ( IS_NPC(victim) )
  1724.     {
  1725. send_to_char( "Not on NPC's.nr", ch );
  1726. return;
  1727.     }
  1729.     if ( get_trust( victim ) >= get_trust( ch ) )
  1730.     {
  1731. send_to_char( "You failed.nr", ch );
  1732. return;
  1733.     }
  1735.     if ( IS_SET(victim->act, PLR_NO_TELL) )
  1736.     {
  1737. REMOVE_BIT(victim->act, PLR_NO_TELL);
  1738. send_to_char( "You can tell again.nr", victim );
  1739. send_to_char( "NO_TELL removed.nr", ch );
  1740.     }
  1741.     else
  1742.     {
  1743. SET_BIT(victim->act, PLR_NO_TELL);
  1744. send_to_char( "You can't tell!nr", victim );
  1745. send_to_char( "NO_TELL set.nr", ch );
  1746.     }
  1748.     return;
  1749. }
  1753. void do_silence( CHAR_DATA *ch, char *argument )
  1754. {
  1755.     char arg[MAX_INPUT_LENGTH];
  1756.     CHAR_DATA *victim;
  1758.     one_argument( argument, arg );
  1760.     if ( arg[0] == '' )
  1761.     {
  1762. send_to_char( "Silence whom?", ch );
  1763. return;
  1764.     }
  1766.     if ( ( victim = get_char_world( ch, arg ) ) == NULL )
  1767.     {
  1768. send_to_char( "They aren't here.nr", ch );
  1769. return;
  1770.     }
  1772.     if ( IS_NPC(victim) )
  1773.     {
  1774. send_to_char( "Not on NPC's.nr", ch );
  1775. return;
  1776.     }
  1778.     if ( get_trust( victim ) >= get_trust( ch ) )
  1779.     {
  1780. send_to_char( "You failed.nr", ch );
  1781. return;
  1782.     }
  1784.     if ( IS_SET(victim->act, PLR_SILENCE) )
  1785.     {
  1786. REMOVE_BIT(victim->act, PLR_SILENCE);
  1787. send_to_char( "You can use channels again.nr", victim );
  1788. send_to_char( "SILENCE removed.nr", ch );
  1789.     }
  1790.     else
  1791.     {
  1792. SET_BIT(victim->act, PLR_SILENCE);
  1793. send_to_char( "You can't use channels!nr", victim );
  1794. send_to_char( "SILENCE set.nr", ch );
  1795.     }
  1797.     return;
  1798. }
  1802. void do_peace( CHAR_DATA *ch, char *argument )
  1803. {
  1804.     CHAR_DATA *rch;
  1806.     for ( rch = ch->in_room->people; rch != NULL; rch = rch->next_in_room )
  1807.     {
  1808. if ( rch->fighting != NULL )
  1809.     stop_fighting( rch, TRUE );
  1810.     }
  1812.     send_to_char( "Ok.nr", ch );
  1813.     return;
  1814. }
  1818. BAN_DATA * ban_free;
  1819. BAN_DATA * ban_list;
  1821. void do_ban( CHAR_DATA *ch, char *argument )
  1822. {
  1823. #if 0
  1824.     char buf[MAX_STRING_LENGTH];
  1825.     char arg[MAX_INPUT_LENGTH];
  1826.     BAN_DATA *pban;
  1828.     if ( IS_NPC(ch) )
  1829. return;
  1831.     one_argument( argument, arg );
  1833.     if ( arg[0] == '' )
  1834.     {
  1835. strcpy( buf, "Banned sites:nr" );
  1836. for ( pban = ban_list; pban != NULL; pban = pban->next )
  1837. {
  1838.     strcat( buf, pban->name );
  1839.     strcat( buf, "nr" );
  1840. }
  1841. send_to_char( buf, ch );
  1842. return;
  1843.     }
  1845.     for ( pban = ban_list; pban != NULL; pban = pban->next )
  1846.     {
  1847. if ( !str_cmp( arg, pban->name ) )
  1848. {
  1849.     send_to_char( "That site is already banned!nr", ch );
  1850.     return;
  1851. }
  1852.     }
  1854.     if ( ban_free == NULL )
  1855.     {
  1856. pban = alloc_perm( sizeof(*pban) );
  1857.     }
  1858.     else
  1859.     {
  1860. pban = ban_free;
  1861. ban_free = ban_free->next;
  1862.     }
  1864.     pban->name = str_dup( arg );
  1865.     pban->next = ban_list;
  1866.     ban_list = pban;
  1867.     send_to_char( "Ok.nr", ch );
  1868.     return;
  1869. #else
  1870.    send_to_char( "Site banning has been disabled, as site checking at connect"
  1871.       " can lag the server.nr", ch);
  1872. #endif
  1873. }
  1877. void do_allow( CHAR_DATA *ch, char *argument )
  1878. {
  1879.     char arg[MAX_INPUT_LENGTH];
  1880.     BAN_DATA *prev;
  1881.     BAN_DATA *curr;
  1883.     one_argument( argument, arg );
  1885.     if ( arg[0] == '' )
  1886.     {
  1887. send_to_char( "Remove which site from the ban list?nr", ch );
  1888. return;
  1889.     }
  1891.     prev = NULL;
  1892.     for ( curr = ban_list; curr != NULL; prev = curr, curr = curr->next )
  1893.     {
  1894. if ( !str_cmp( arg, curr->name ) )
  1895. {
  1896.     if ( prev == NULL )
  1897. ban_list   = ban_list->next;
  1898.     else
  1899. prev->next = curr->next;
  1901.     free_string( curr->name );
  1902.     curr->next = ban_free;
  1903.     ban_free = curr;
  1904.     send_to_char( "Ok.nr", ch );
  1905.     return;
  1906. }
  1907.     }
  1909.     send_to_char( "Site is not banned.nr", ch );
  1910.     return;
  1911. }
  1915. void do_wizlock( CHAR_DATA *ch, char *argument )
  1916. {
  1917.     extern bool wizlock;
  1918.     wizlock = !wizlock;
  1920.     if ( wizlock )
  1921. send_to_char( "Game wizlocked.nr", ch );
  1922.     else
  1923. send_to_char( "Game un-wizlocked.nr", ch );
  1925.     return;
  1926. }
  1930. void do_slookup( CHAR_DATA *ch, char *argument )
  1931. {
  1932.     char buf[5*MAX_STRING_LENGTH];
  1933.     char buf1[5*MAX_STRING_LENGTH];
  1934.     char arg[MAX_INPUT_LENGTH];
  1935.     int sn;
  1937.     one_argument( argument, arg );
  1938.     if ( arg[0] == '' )
  1939.     {
  1940. send_to_char( "Slookup what?nr", ch );
  1941. return;
  1942.     }
  1944.     if ( !str_cmp( arg, "all" ) )
  1945.     {
  1946.         buf1[0] = '';
  1947. for ( sn = 0; sn < MAX_SKILL; sn++ )
  1948. {
  1949.     if ( skill_table[sn].name == NULL )
  1950. break;
  1951.     sprintf( buf, "Sn: %4d Slot: %4d Skill/spell: '%s'nr",
  1952. sn, skill_table[sn].slot, skill_table[sn].name );
  1953.     strcat( buf1, buf );
  1954. }
  1955. send_to_char( buf1, ch );
  1956.     }
  1957.     else
  1958.     {
  1959. if ( ( sn = skill_lookup( arg ) ) < 0 )
  1960. {
  1961.     send_to_char( "No such skill or spell.nr", ch );
  1962.     return;
  1963. }
  1965. sprintf( buf, "Sn: %4d Slot: %4d Skill/spell: '%s'nr",
  1966.     sn, skill_table[sn].slot, skill_table[sn].name );
  1967. send_to_char( buf, ch );
  1968.     }
  1970.     return;
  1971. }
  1975. void do_sset( CHAR_DATA *ch, char *argument )
  1976. {
  1977.     char arg1 [MAX_INPUT_LENGTH];
  1978.     char arg2 [MAX_INPUT_LENGTH];
  1979.     char arg3 [MAX_INPUT_LENGTH];
  1980.     CHAR_DATA *victim;
  1981.     int value;
  1982.     int sn;
  1983.     bool fAll;
  1985.     argument = one_argument( argument, arg1 );
  1986.     argument = one_argument( argument, arg2 );
  1987.     argument = one_argument( argument, arg3 );
  1989.     if ( arg1[0] == '' || arg2[0] == '' || arg3[0] == '' )
  1990.     {
  1991. send_to_char( "Syntax: sset <victim> <skill> <value>nr", ch );
  1992. send_to_char( "or:     sset <victim> all     <value>nr", ch );
  1993. send_to_char( "Skill being any skill or spell.nr", ch );
  1994. return;
  1995.     }
  1997.     if ( ( victim = get_char_world( ch, arg1 ) ) == NULL )
  1998.     {
  1999. send_to_char( "They aren't here.nr", ch );
  2000. return;
  2001.     }
  2003.     if ( IS_NPC(victim) )
  2004.     {
  2005. send_to_char( "Not on NPC's.nr", ch );
  2006. return;
  2007.     }
  2009.     fAll = !str_cmp( arg2, "all" );
  2010.     sn   = 0;
  2011.     if ( !fAll && ( sn = skill_lookup( arg2 ) ) < 0 )
  2012.     {
  2013. send_to_char( "No such skill or spell.nr", ch );
  2014. return;
  2015.     }
  2017.     /*
  2018.      * Snarf the value.
  2019.      */
  2020.     if ( !is_number( arg3 ) )
  2021.     {
  2022. send_to_char( "Value must be numeric.nr", ch );
  2023. return;
  2024.     }
  2026.     value = atoi( arg3 );
  2027.     if ( value < 0 || value > 100 )
  2028.     {
  2029. send_to_char( "Value range is 0 to 100.nr", ch );
  2030. return;
  2031.     }
  2033.     if ( fAll )
  2034.     {
  2035. for ( sn = 0; sn < MAX_SKILL; sn++ )
  2036. {
  2037.     if ( skill_table[sn].name != NULL )
  2038. victim->pcdata->learned[sn] = value;
  2039. }
  2040.     }
  2041.     else
  2042.     {
  2043. victim->pcdata->learned[sn] = value;
  2044.     }
  2046.     return;
  2047. }
  2051. void do_mset( CHAR_DATA *ch, char *argument )
  2052. {
  2053.     char arg1 [MAX_INPUT_LENGTH];
  2054.     char arg2 [MAX_INPUT_LENGTH];
  2055.     char arg3 [MAX_INPUT_LENGTH];
  2056.     char buf  [MAX_STRING_LENGTH];
  2057.     CHAR_DATA *victim;
  2058.     int value, max;
  2060.     smash_tilde( argument );
  2061.     argument = one_argument( argument, arg1 );
  2062.     argument = one_argument( argument, arg2 );
  2063.     strcpy( arg3, argument );
  2065.     if ( arg1[0] == '' || arg2[0] == '' || arg3[0] == '' )
  2066.     {
  2067. send_to_char( "Syntax: mset <victim> <field>  <value>nr", ch );
  2068. send_to_char( "or:     mset <victim> <string> <value>nr", ch );
  2069. send_to_char( "nr", ch );
  2070. send_to_char( "Field being one of:nr", ch );
  2071. send_to_char( "  str int wis dex con sex class levelnr", ch );
  2072. send_to_char( "  gold hp mana move practice alignnr", ch );
  2073. send_to_char( "  thirst drunk full race", ch );
  2074. send_to_char( "nr", ch );
  2075. send_to_char( "String being one of:nr", ch );
  2076. send_to_char( "  name short long description title specnr", ch );
  2077. return;
  2078.     }
  2080.     if ( ( victim = get_char_world( ch, arg1 ) ) == NULL )
  2081.     {
  2082. send_to_char( "They aren't here.nr", ch );
  2083. return;
  2084.     }
  2086.     /*
  2087.      * Snarf the value (which need not be numeric).
  2088.      */
  2089.     value = is_number( arg3 ) ? atoi( arg3 ) : -1;
  2091.     /*
  2092.      * Set something.
  2093.      */
  2094.     if ( !str_cmp( arg2, "str" ) )
  2095.     {
  2096. if ( IS_NPC(victim) )
  2097. {
  2098.     send_to_char( "Not on NPC's.nr", ch );
  2099.     return;
  2100. }
  2102. if ( class_table[ch->class].attr_prime == APPLY_STR )
  2103.     max = 25;
  2104. else
  2105.     max = 18;
  2107. if ( value < 3 || value > max )
  2108. {
  2109.     sprintf( buf, "Strength range is 3 to %d.nr", max );
  2110.     send_to_char( buf, ch );
  2111.     return;
  2112. }
  2114. victim->pcdata->perm_str = value;
  2115. return;
  2116.     }
  2118.     if ( !str_cmp( arg2, "int" ) )
  2119.     {
  2120. if ( IS_NPC(victim) )
  2121. {
  2122.     send_to_char( "Not on NPC's.nr", ch );
  2123.     return;
  2124. }
  2126. if ( class_table[ch->class].attr_prime == APPLY_INT )
  2127.     max = 25;
  2128. else
  2129.     max = 18;
  2131. if ( value < 3 || value > max )
  2132. {
  2133.     sprintf( buf, "Intelligence range is 3 to %d.nr", max );
  2134.     send_to_char( buf, ch );
  2135.     return;
  2136. }
  2138. victim->pcdata->perm_int = value;
  2139. return;
  2140.     }
  2142.     if ( !str_cmp( arg2, "wis" ) )
  2143.     {
  2144. if ( IS_NPC(victim) )
  2145. {
  2146.     send_to_char( "Not on NPC's.nr", ch );
  2147.     return;
  2148. }
  2150. if ( class_table[ch->class].attr_prime == APPLY_WIS )
  2151.     max = 25;
  2152. else
  2153.     max = 18;
  2155. if ( value < 3 || value > max )
  2156. {
  2157.     sprintf( buf, "Wisdom range is 3 to %d.nr", max );
  2158.     send_to_char( buf, ch );
  2159.     return;
  2160. }
  2162. victim->pcdata->perm_wis = value;
  2163. return;
  2164.     }
  2166.     if ( !str_cmp( arg2, "dex" ) )
  2167.     {
  2168. if ( IS_NPC(victim) )
  2169. {
  2170.     send_to_char( "Not on NPC's.nr", ch );
  2171.     return;
  2172. }
  2174. if ( class_table[ch->class].attr_prime == APPLY_DEX )
  2175.     max = 25;
  2176. else
  2177.     max = 18;
  2179. if ( value < 3 || value > max )
  2180. {
  2181.     sprintf( buf, "Dexterity range is 3 to %d.nr", max );
  2182.     send_to_char( buf, ch );
  2183.     return;
  2184. }
  2186. victim->pcdata->perm_dex = value;
  2187. return;
  2188.     }
  2190.     if ( !str_cmp( arg2, "con" ) )
  2191.     {
  2192. if ( IS_NPC(victim) )
  2193. {
  2194.     send_to_char( "Not on NPC's.nr", ch );
  2195.     return;
  2196. }
  2198. if ( class_table[ch->class].attr_prime == APPLY_CON )
  2199.     max = 25;
  2200. else
  2201.     max = 18;
  2203. if ( value < 3 || value > max )
  2204. {
  2205.     sprintf( buf, "Constitution range is 3 to %d.nr", max );
  2206.     send_to_char( buf, ch );
  2207.     return;
  2208. }
  2210. victim->pcdata->perm_con = value;
  2211. return;
  2212.     }
  2214.     if ( !str_cmp( arg2, "sex" ) )
  2215.     {
  2216. if ( value < 0 || value > 2 )
  2217. {
  2218.     send_to_char( "Sex range is 0 to 2.nr", ch );
  2219.     return;
  2220. }
  2221. victim->sex = value;
  2222. return;
  2223.     }
  2225.     if ( !str_cmp( arg2, "class" ) )
  2226.     {
  2227. if ( value < 0 || value >= MAX_CLASS )
  2228. {
  2229.     char buf[MAX_STRING_LENGTH];
  2231.     sprintf( buf, "Class range is 0 to %d.n", MAX_CLASS-1 );
  2232.     send_to_char( buf, ch );
  2233.     return;
  2234. }
  2235. victim->class = value;
  2236. return;
  2237.     }
  2239.     if ( !str_cmp( arg2, "race" ) )
  2240.     {
  2241. if ( value < 0 || value >= MAX_RACE )
  2242. {
  2243.     char buf[MAX_STRING_LENGTH];
  2245.     sprintf( buf, "Race range is 0 to %d.n", MAX_RACE-1 );
  2246.     send_to_char( buf, ch );
  2247.     return;
  2248. }
  2249. victim->race = value;
  2250. return;
  2251.     }
  2253.     if ( !str_cmp( arg2, "level" ) )
  2254.     {
  2255. if ( !IS_NPC(victim) )
  2256. {
  2257.     send_to_char( "Not on PC's.nr", ch );
  2258.     return;
  2259. }
  2261. if ( value < 0 || value > 50 )
  2262. {
  2263.     send_to_char( "Level range is 0 to 50.nr", ch );
  2264.     return;
  2265. }
  2266. victim->level = value;
  2267. return;
  2268.     }
  2270.     if ( !str_cmp( arg2, "gold" ) )
  2271.     {
  2272. victim->gold = value;
  2273. return;
  2274.     }
  2276.     if ( !str_cmp( arg2, "hp" ) )
  2277.     {
  2278. if ( value < -10 || value > 30000 )
  2279. {
  2280.     send_to_char( "Hp range is -10 to 30,000 hit points.nr", ch );
  2281.     return;
  2282. }
  2283. victim->max_hit = value;
  2284. return;
  2285.     }
  2287.     if ( !str_cmp( arg2, "mana" ) )
  2288.     {
  2289. if ( value < 0 || value > 30000 )
  2290. {
  2291.     send_to_char( "Mana range is 0 to 30,000 mana points.nr", ch );
  2292.     return;
  2293. }
  2294. victim->max_mana = value;
  2295. return;
  2296.     }
  2298.     if ( !str_cmp( arg2, "move" ) )
  2299.     {
  2300. if ( value < 0 || value > 30000 )
  2301. {
  2302.     send_to_char( "Move range is 0 to 30,000 move points.nr", ch );
  2303.     return;
  2304. }
  2305. victim->max_move = value;
  2306. return;
  2307.     }
  2309.     if ( !str_cmp( arg2, "practice" ) )
  2310.     {
  2311. if ( value < 0 || value > 100 )
  2312. {
  2313.     send_to_char( "Practice range is 0 to 100 sessions.nr", ch );
  2314.     return;
  2315. }
  2316. victim->practice = value;
  2317. return;
  2318.     }
  2320.     if ( !str_cmp( arg2, "align" ) )
  2321.     {
  2322. if ( value < -1000 || value > 1000 )
  2323. {
  2324.     send_to_char( "Alignment range is -1000 to 1000.nr", ch );
  2325.     return;
  2326. }
  2327. victim->alignment = value;
  2328. return;
  2329.     }
  2331.     if ( !str_cmp( arg2, "thirst" ) )
  2332.     {
  2333. if ( IS_NPC(victim) )
  2334. {
  2335.     send_to_char( "Not on NPC's.nr", ch );
  2336.     return;
  2337. }
  2339. if ( value < 0 || value > 100 )
  2340. {
  2341.     send_to_char( "Thirst range is 0 to 100.nr", ch );
  2342.     return;
  2343. }
  2345. victim->pcdata->condition[COND_THIRST] = value;
  2346. return;
  2347.     }
  2349.     if ( !str_cmp( arg2, "drunk" ) )
  2350.     {
  2351. if ( IS_NPC(victim) )
  2352. {
  2353.     send_to_char( "Not on NPC's.nr", ch );
  2354.     return;
  2355. }
  2357. if ( value < 0 || value > 100 )
  2358. {
  2359.     send_to_char( "Drunk range is 0 to 100.nr", ch );
  2360.     return;
  2361. }
  2363. victim->pcdata->condition[COND_DRUNK] = value;
  2364. return;
  2365.     }
  2367.     if ( !str_cmp( arg2, "full" ) )
  2368.     {
  2369. if ( IS_NPC(victim) )
  2370. {
  2371.     send_to_char( "Not on NPC's.nr", ch );
  2372.     return;
  2373. }
  2375. if ( value < 0 || value > 100 )
  2376. {
  2377.     send_to_char( "Full range is 0 to 100.nr", ch );
  2378.     return;
  2379. }
  2381. victim->pcdata->condition[COND_FULL] = value;
  2382. return;
  2383.     }
  2385.     if ( !str_cmp( arg2, "name" ) )
  2386.     {
  2387. if ( !IS_NPC(victim) )
  2388. {
  2389.     send_to_char( "Not on PC's.nr", ch );
  2390.     return;
  2391. }
  2393. free_string( victim->name );
  2394. victim->name = str_dup( arg3 );
  2395. return;
  2396.     }
  2398.     if ( !str_cmp( arg2, "short" ) )
  2399.     {
  2400. free_string( victim->short_descr );
  2401. victim->short_descr = str_dup( arg3 );
  2402. return;
  2403.     }
  2405.     if ( !str_cmp( arg2, "long" ) )
  2406.     {
  2407. free_string( victim->long_descr );
  2408. victim->long_descr = str_dup( arg3 );
  2409. return;
  2410.     }
  2412.     if ( !str_cmp( arg2, "title" ) )
  2413.     {
  2414. if ( IS_NPC(victim) )
  2415. {
  2416.     send_to_char( "Not on NPC's.nr", ch );
  2417.     return;
  2418. }
  2420. set_title( victim, arg3 );
  2421. return;
  2422.     }
  2424.     if ( !str_cmp( arg2, "spec" ) )
  2425.     {
  2426. if ( !IS_NPC(victim) )
  2427. {
  2428.     send_to_char( "Not on PC's.nr", ch );
  2429.     return;
  2430. }
  2432. if ( ( victim->spec_fun = spec_lookup( arg3 ) ) == 0 )
  2433. {
  2434.     send_to_char( "No such spec fun.nr", ch );
  2435.     return;
  2436. }
  2438. return;
  2439.     }
  2441.     /*
  2442.      * Generate usage message.
  2443.      */
  2444.     do_mset( ch, "" );
  2445.     return;
  2446. }
  2450. void do_oset( CHAR_DATA *ch, char *argument )
  2451. {
  2452.     char arg1 [MAX_INPUT_LENGTH];
  2453.     char arg2 [MAX_INPUT_LENGTH];
  2454.     char arg3 [MAX_INPUT_LENGTH];
  2455.     OBJ_DATA *obj;
  2456.     int value;
  2458.     smash_tilde( argument );
  2459.     argument = one_argument( argument, arg1 );
  2460.     argument = one_argument( argument, arg2 );
  2461.     strcpy( arg3, argument );
  2463.     if ( arg1[0] == '' || arg2[0] == '' || arg3[0] == '' )
  2464.     {
  2465. send_to_char( "Syntax: oset <object> <field>  <value>nr", ch );
  2466. send_to_char( "or:     oset <object> <string> <value>nr", ch );
  2467. send_to_char( "nr", ch );
  2468. send_to_char( "Field being one of:nr", ch );
  2469. send_to_char( "  value0 value1 value2 value3nr", ch );
  2470. send_to_char( "  extra wear level weight cost timernr", ch );
  2471. send_to_char( "nr", ch );
  2472. send_to_char( "String being one of:nr", ch );
  2473. send_to_char( "  name short long ednr", ch );
  2474. return;
  2475.     }
  2477.     if ( ( obj = get_obj_world( ch, arg1 ) ) == NULL )
  2478.     {
  2479. send_to_char( "Nothing like that in hell, earth, or heaven.nr", ch );
  2480. return;
  2481.     }
  2483.     /*
  2484.      * Snarf the value (which need not be numeric).
  2485.      */
  2486.     value = atoi( arg3 );
  2488.     /*
  2489.      * Set something.
  2490.      */
  2491.     if ( !str_cmp( arg2, "value0" ) || !str_cmp( arg2, "v0" ) )
  2492.     {
  2493. obj->value[0] = value;
  2494. return;
  2495.     }
  2497.     if ( !str_cmp( arg2, "value1" ) || !str_cmp( arg2, "v1" ) )
  2498.     {
  2499. obj->value[1] = value;
  2500. return;
  2501.     }
  2503.     if ( !str_cmp( arg2, "value2" ) || !str_cmp( arg2, "v2" ) )
  2504.     {
  2505. obj->value[2] = value;
  2506. return;
  2507.     }
  2509.     if ( !str_cmp( arg2, "value3" ) || !str_cmp( arg2, "v3" ) )
  2510.     {
  2511. obj->value[3] = value;
  2512. return;
  2513.     }
  2515.     if ( !str_cmp( arg2, "extra" ) )
  2516.     {
  2517. obj->extra_flags = value;
  2518. return;
  2519.     }
  2521.     if ( !str_cmp( arg2, "wear" ) )
  2522.     {
  2523. obj->wear_flags = value;
  2524. return;
  2525.     }
  2527.     if ( !str_cmp( arg2, "level" ) )
  2528.     {
  2529. obj->level = value;
  2530. return;
  2531.     }
  2533.     if ( !str_cmp( arg2, "weight" ) )
  2534.     {
  2535. obj->weight = value;
  2536. return;
  2537.     }
  2539.     if ( !str_cmp( arg2, "cost" ) )
  2540.     {
  2541. obj->cost = value;
  2542. return;
  2543.     }
  2545.     if ( !str_cmp( arg2, "timer" ) )
  2546.     {
  2547. obj->timer = value;
  2548. return;
  2549.     }
  2551.     if ( !str_cmp( arg2, "name" ) )
  2552.     {
  2553. free_string( obj->name );
  2554. obj->name = str_dup( arg3 );
  2555. return;
  2556.     }
  2558.     if ( !str_cmp( arg2, "short" ) )
  2559.     {
  2560. free_string( obj->short_descr );
  2561. obj->short_descr = str_dup( arg3 );
  2562. return;
  2563.     }
  2565.     if ( !str_cmp( arg2, "long" ) )
  2566.     {
  2567. free_string( obj->description );
  2568. obj->description = str_dup( arg3 );
  2569. return;
  2570.     }
  2572.     if ( !str_cmp( arg2, "ed" ) )
  2573.     {
  2574. EXTRA_DESCR_DATA *ed;
  2576. argument = one_argument( argument, arg3 );
  2577. if ( argument == NULL )
  2578. {
  2579.     send_to_char( "Syntax: oset <object> ed <keyword> <string>nr",
  2580. ch );
  2581.     return;
  2582. }
  2584. if ( extra_descr_free == NULL )
  2585. {
  2586.     ed = alloc_perm( sizeof(*ed) );
  2587. }
  2588. else
  2589. {
  2590.     ed = extra_descr_free;
  2591.     extra_descr_free = extra_descr_free->next;
  2592. }
  2594. ed->keyword = str_dup( arg3     );
  2595. ed->description = str_dup( argument );
  2596. ed->next = obj->extra_descr;
  2597. obj->extra_descr = ed;
  2598. return;
  2599.     }
  2601.     /*
  2602.      * Generate usage message.
  2603.      */
  2604.     do_oset( ch, "" );
  2605.     return;
  2606. }
  2610. void do_rset( CHAR_DATA *ch, char *argument )
  2611. {
  2612.     char arg1 [MAX_INPUT_LENGTH];
  2613.     char arg2 [MAX_INPUT_LENGTH];
  2614.     char arg3 [MAX_INPUT_LENGTH];
  2615.     ROOM_INDEX_DATA *location;
  2616.     int value;
  2618.     smash_tilde( argument );
  2619.     argument = one_argument( argument, arg1 );
  2620.     argument = one_argument( argument, arg2 );
  2621.     strcpy( arg3, argument );
  2623.     if ( arg1[0] == '' || arg2[0] == '' || arg3[0] == '' )
  2624.     {
  2625. send_to_char( "Syntax: rset <location> <field> valuenr", ch );
  2626. send_to_char( "nr", ch );
  2627. send_to_char( "Field being one of:nr", ch );
  2628. send_to_char( "  flags sectornr", ch );
  2629. return;
  2630.     }
  2632.     if ( ( location = find_location( ch, arg1 ) ) == NULL )
  2633.     {
  2634. send_to_char( "No such location.nr", ch );
  2635. return;
  2636.     }
  2638.     /*
  2639.      * Snarf the value.
  2640.      */
  2641.     if ( !is_number( arg3 ) )
  2642.     {
  2643. send_to_char( "Value must be numeric.nr", ch );
  2644. return;
  2645.     }
  2646.     value = atoi( arg3 );
  2648.     /*
  2649.      * Set something.
  2650.      */
  2651.     if ( !str_cmp( arg2, "flags" ) )
  2652.     {
  2653. location->room_flags = value;
  2654. return;
  2655.     }
  2657.     if ( !str_cmp( arg2, "sector" ) )
  2658.     {
  2659. location->sector_type = value;
  2660. return;
  2661.     }
  2663.     /*
  2664.      * Generate usage message.
  2665.      */
  2666.     do_rset( ch, "" );
  2667.     return;
  2668. }
  2671. #ifndef WIN32
  2672. void do_users( CHAR_DATA *ch, char *argument )
  2673. {
  2674.     char buf[MAX_STRING_LENGTH];
  2675.     char buf2[MAX_STRING_LENGTH];
  2676.     DESCRIPTOR_DATA *d;
  2677.     int count;
  2679.     count = 0;
  2680.     buf[0] = '';
  2681.     buf2[0]     = '';
  2682.     for ( d = descriptor_list; d != NULL; d = d->next )
  2683.     {
  2684. if ( d->character != NULL && can_see( ch, d->character ) )
  2685. {
  2686.     count++;
  2687.     sprintf( buf + strlen(buf), "[%3d %2d] %s (" /*"%s@"*/ "%s)nr",
  2688. d->descriptor,
  2689. d->connected,
  2690. d->original  ? d->original->name  :
  2691. d->character ? d->character->name : "(none)",
  2692. /*d->host_and_name->username,*/ d->host
  2693. );
  2694. }
  2695.     }
  2697.     sprintf( buf2, "%d user%snr", count, count == 1 ? "" : "s" );
  2698.     strcat( buf, buf2 );
  2699.     send_to_char( buf, ch );
  2700.     return;
  2701. }
  2702. #endif
  2705. /*
  2706.  * Thanks to Grodyn for pointing out bugs in this function.
  2707.  */
  2708. void do_force( CHAR_DATA *ch, char *argument )
  2709. {
  2710.     char arg[MAX_INPUT_LENGTH];
  2711.     int trust;
  2712.     int cmd;
  2714.     argument = one_argument( argument, arg );
  2716.     if ( arg[0] == '' || argument[0] == '' )
  2717.     {
  2718. send_to_char( "Force whom to do what?nr", ch );
  2719. return;
  2720.     }
  2722.     /*
  2723.      * Look for command in command table.
  2724.      */
  2725.     trust = get_trust( ch );
  2726.     for ( cmd = 0; cmd_table[cmd].name[0] != ''; cmd++ )
  2727.     {
  2728. if ( argument[0] == cmd_table[cmd].name[0]
  2729.     &&   !str_prefix( argument, cmd_table[cmd].name )
  2730.     &&   ( cmd_table[cmd].level > trust 
  2731.   && cmd_table[cmd].level != 41 ) )
  2732. {
  2733.   send_to_char( "You cant even do that yourself!nr", ch );
  2734.   return;
  2735. }
  2736.     }
  2738.     if ( !str_cmp( arg, "all" ) )
  2739.     {
  2740. CHAR_DATA *vch;
  2741. CHAR_DATA *vch_next;
  2743. for ( vch = char_list; vch != NULL; vch = vch_next )
  2744. {
  2745.     vch_next = vch->next;
  2747.     if ( !IS_NPC(vch) && get_trust( vch ) < get_trust( ch ) )
  2748.     {
  2749.         MOBtrigger = FALSE;
  2750. act( "$n forces you to '$t'.", ch, argument, vch, TO_VICT );
  2751. interpret( vch, argument );
  2752.     }
  2753. }
  2754.     }
  2755.     else
  2756.     {
  2757. CHAR_DATA *victim;
  2759. if ( ( victim = get_char_world( ch, arg ) ) == NULL )
  2760. {
  2761.     send_to_char( "They aren't here.nr", ch );
  2762.     return;
  2763. }
  2765. if ( victim == ch )
  2766. {
  2767.     send_to_char( "Aye aye, right away!nr", ch );
  2768.     return;
  2769. }
  2771. if ( get_trust( victim ) >= get_trust( ch ) )
  2772. {
  2773.     send_to_char( "Do it yourself!nr", ch );
  2774.     return;
  2775. }
  2777. MOBtrigger = FALSE;
  2778. act( "$n forces you to '$t'.", ch, argument, victim, TO_VICT );
  2779. interpret( victim, argument );
  2780.     }
  2782.     send_to_char( "Ok.nr", ch );
  2783.     return;
  2784. }
  2788. /*
  2789.  * New routines by Dionysos.
  2790.  */
  2791. void do_invis( CHAR_DATA *ch, char *argument )
  2792. {
  2793.     if ( IS_NPC(ch) )
  2794. return;
  2796.     if ( IS_SET(ch->act, PLR_WIZINVIS) )
  2797.     {
  2798. REMOVE_BIT(ch->act, PLR_WIZINVIS);
  2799. act( "$n slowly fades into existence.", ch, NULL, NULL, TO_ROOM );
  2800. send_to_char( "You slowly fade back into existence.nr", ch );
  2801.     }
  2802.     else
  2803.     {
  2804. SET_BIT(ch->act, PLR_WIZINVIS);
  2805. act( "$n slowly fades into thin air.", ch, NULL, NULL, TO_ROOM );
  2806. send_to_char( "You slowly vanish into thin air.nr", ch );
  2807.     }
  2809.     return;
  2810. }
  2814. void do_holylight( CHAR_DATA *ch, char *argument )
  2815. {
  2816.     if ( IS_NPC(ch) )
  2817. return;
  2819.     if ( IS_SET(ch->act, PLR_HOLYLIGHT) )
  2820.     {
  2821. REMOVE_BIT(ch->act, PLR_HOLYLIGHT);
  2822. send_to_char( "Holy light mode off.nr", ch );
  2823.     }
  2824.     else
  2825.     {
  2826. SET_BIT(ch->act, PLR_HOLYLIGHT);
  2827. send_to_char( "Holy light mode on.nr", ch );
  2828.     }
  2830.     return;
  2831. }
  2833. /* Wizify and Wizbit sent in by M. B. King */
  2835. void do_wizify( CHAR_DATA *ch, char *argument )
  2836. {
  2837.     char arg1[MAX_INPUT_LENGTH];
  2838.     CHAR_DATA *victim;
  2839.   
  2840.     argument = one_argument( argument, arg1  );
  2841.     if ( arg1[0] == '' )
  2842.     {
  2843. send_to_char( "Syntax: wizify <name>nr" , ch );
  2844. return;
  2845.     }
  2846.     if ( ( victim = get_char_world( ch, arg1 ) ) == NULL )
  2847.     {
  2848. send_to_char( "They aren't here.nr" , ch );
  2849. return;
  2850.     }
  2851.     if ( IS_NPC( victim ) )
  2852.     {
  2853. send_to_char( "Not on mobs.nr", ch );
  2854. return;
  2855.     }
  2856.     victim->wizbit = !victim->wizbit;
  2857.     if ( victim->wizbit ) 
  2858.     {
  2859. act( "$N wizified.nr", ch, NULL, victim, TO_CHAR );
  2860. act( "$n has wizified you!nr", ch, NULL, victim, TO_VICT );
  2861.     }
  2862.     else
  2863.     {
  2864. act( "$N dewizzed.nr", ch, NULL, victim, TO_CHAR );
  2865. act( "$n has dewizzed you!nr", ch, NULL, victim, TO_VICT ); 
  2866.     }
  2868.     do_save( victim, "");
  2869.     return;
  2870. }
  2872. #if 0
  2873. /* Idea from Talen of Vego's do_where command */
  2875. void do_owhere( CHAR_DATA *ch, char *argument )
  2876. {
  2877.     char buf[MAX_STRING_LENGTH];
  2878.     char arg[MAX_INPUT_LENGTH];
  2879.     bool found = FALSE;
  2880.     OBJ_DATA *obj;
  2881.     OBJ_DATA *in_obj;
  2882.     int obj_counter = 1;
  2884.     one_argument( argument, arg );
  2886.     if( arg[0] == '' )
  2887.     {
  2888. send_to_char( "Syntax:  owhere <object>.nr", ch );
  2889. return;
  2890.     }
  2891.     else
  2892.     {
  2893. for ( obj = object_list; obj != NULL; obj = obj->next )
  2894. {
  2895.     if ( !can_see_obj( ch, obj ) || !is_name( arg, obj->name ) )
  2896.         continue;
  2898.     found = TRUE;
  2900.     for ( in_obj = obj; in_obj->in_obj != NULL;
  2901.  in_obj = in_obj->in_obj )
  2902.         ;
  2904.     if ( in_obj->carried_by != NULL )
  2905.     {
  2906. sprintf( buf, "[%2d] %s carried by %s.nr", obj_counter,
  2907. obj->short_descr, PERS( in_obj->carried_by, ch ) );
  2908.     }
  2909.     else
  2910.     {
  2911. sprintf( buf, "[%2d] %s in %s.nr", obj_counter,
  2912. obj->short_descr, ( in_obj->in_room == NULL ) ?
  2913. "somewhere" : in_obj->in_room->name );
  2914.     }
  2916.     obj_counter++;
  2917.     buf[0] = UPPER( buf[0] );
  2918.     send_to_char( buf, ch );
  2919. }
  2920.     }
  2922.     if ( !found )
  2923. send_to_char(
  2924. "Nothing like that in hell, earth, or heaven.nr" , ch );
  2926.     return;
  2929. }
  2930. #else
  2931. /* Idea from Talen of Vego's do_where command */
  2933.  /*
  2934.   * Modified combination of Merc 2.2, Dalton, and Zavod's  "owhere" commands
  2935.   */
  2937. void do_owhere( CHAR_DATA *ch, char *argument )
  2938. {
  2939.     char buf[MAX_STRING_LENGTH];
  2940.     char arg[MAX_INPUT_LENGTH];
  2941.     bool found = FALSE;
  2942.     OBJ_DATA *obj;
  2943.     OBJ_DATA *in_obj;
  2944.     int obj_counter = 1;
  2945.  
  2946.     one_argument( argument, arg );
  2947.  
  2948.     if( arg[0] == '' )
  2949.       {
  2950.         send_to_char( "Syntax:  owhere <object>.nr", ch );
  2951.         return;
  2952.       }
  2953.     
  2954.     for ( obj = object_list; obj != NULL; obj = obj->next )
  2955.       {
  2956.         if ( !can_see_obj( ch, obj ) || !is_name( arg, obj->name ) )
  2957.             continue;
  2958.  
  2959.         found = TRUE;
  2960.  
  2961.         for ( in_obj = obj; in_obj->in_obj != NULL;
  2962.                 in_obj = in_obj->in_obj ) ;
  2963.  
  2964.         if ( in_obj->carried_by != NULL )
  2965.   {
  2966.         
  2967.             sprintf( buf, "%3d [%4d] %-30s [%4d] %snr", 
  2968.                 obj_counter,
  2969.                 obj->pIndexData->vnum,
  2970.                 obj->short_descr,
  2971. in_obj->carried_by->in_room == NULL ? 0 : in_obj->carried_by->in_room->vnum,
  2972.                 PERS( in_obj->carried_by, ch ) );
  2973.  
  2974.   }
  2975.         else
  2976.   {
  2977.  
  2978.             sprintf( buf, "%3d [%4d] %-30s [%4d] %snr",
  2979.                 obj_counter,
  2980.                 obj->pIndexData->vnum,
  2981.                 obj->short_descr,
  2982.                 in_obj->in_room == NULL ? 0 : in_obj->in_room->vnum,
  2983.                 in_obj->in_room == NULL ? "somewhere" : in_obj->in_room->name );
  2984.   }
  2985.             
  2986.         obj_counter++;
  2987.         send_to_char( buf, ch );
  2988.       }
  2989.  
  2990.     if ( !found )
  2991.         send_to_char(
  2992.                 "Nothing like that in hell, earth, or heaven.nr" , ch );
  2993.     return;
  2994.  
  2995. }
  2996. #endif