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

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

Internet/网络编程

开发平台：

WINDOWS

ACT_MOVE.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 <string.h>
  25. #include <time.h>
  26. #include "merc.h"
  30. char * const dir_name [] =
  31. {
  32.     "north", "east", "south", "west", "up", "down"
  33. };
  35. const sh_int rev_dir [] =
  36. {
  37.     2, 3, 0, 1, 5, 4
  38. };
  40. const sh_int movement_loss [SECT_MAX] =
  41. {
  42.     1, 2, 2, 3, 4, 6, 4, 1, 6, 10, 6
  43. };
  47. /*
  48.  * Local functions.
  49.  */
  50. int find_door args( ( CHAR_DATA *ch, char *arg ) );
  51. bool has_key args( ( CHAR_DATA *ch, int key ) );
  55. void move_char( CHAR_DATA *ch, int door )
  56. {
  57.     CHAR_DATA *fch;
  58.     CHAR_DATA *fch_next;
  59.     ROOM_INDEX_DATA *in_room;
  60.     ROOM_INDEX_DATA *to_room;
  61.     EXIT_DATA *pexit;
  63.     if ( door < 0 || door > 5 )
  64.     {
  65. bug( "Do_move: bad door %d.", door );
  66. return;
  67.     }
  69.     in_room = ch->in_room;
  71.     /* Here is where racial cities attach to the guilds... */
  72.     if (in_room->vnum == 201 && door == 0)
  73.        {
  74.        static EXIT_DATA racial_exit;
  75.        racial_exit.vnum = race_table[ch->race].city_vnum;
  76.        racial_exit.to_room = get_room_index(racial_exit.vnum);
  77.        pexit = &racial_exit;
  78.        }
  79.     else
  80.        pexit = in_room->exit[door];
  82.     if ( ( pexit   /*= in_room->exit[door]*/ ) == NULL
  83.     ||   ( to_room = pexit->to_room      ) == NULL )
  84.     {
  85. send_to_char( "Alas, you cannot go that way.nr", ch );
  86. return;
  87.     }
  89.     if ( IS_SET(pexit->exit_info, EX_CLOSED)
  90.     &&   !IS_AFFECTED(ch, AFF_PASS_DOOR) )
  91.     {
  92. act( "The $d is closed.", ch, NULL, pexit->keyword, TO_CHAR );
  93. return;
  94.     }
  96.     if ( IS_AFFECTED(ch, AFF_CHARM)
  97.     &&   ch->master != NULL
  98.     &&   in_room == ch->master->in_room )
  99.     {
  100. send_to_char( "What?  And leave your beloved master?nr", ch );
  101. return;
  102.     }
  104.     if ( room_is_private( to_room ) )
  105.     {
  106. send_to_char( "That room is private right now.nr", ch );
  107. return;
  108.     }
  110.     if ( !IS_NPC(ch) )
  111.     {
  112. int iClass;
  113. int move;
  115. for ( iClass = 0; iClass < MAX_CLASS; iClass++ )
  116. {
  117.     if ( iClass != ch->class
  118.     &&   to_room->vnum == class_table[iClass].guild )
  119.     {
  120. send_to_char( "You aren't allowed in there.nr", ch );
  121. return;
  122.     }
  123. }
  125. if ( in_room->sector_type == SECT_AIR
  126. ||   to_room->sector_type == SECT_AIR )
  127. {
  128.     if ( !IS_AFFECTED(ch, AFF_FLYING) )
  129.     {
  130. send_to_char( "You can't fly.nr", ch );
  131. return;
  132.     }
  133. }
  135. if ( in_room->sector_type == SECT_WATER_NOSWIM
  136. ||   to_room->sector_type == SECT_WATER_NOSWIM )
  137. {
  138.     OBJ_DATA *obj;
  139.     bool found;
  141.     /*
  142.      * Look for a boat.
  143.      */
  144.     found = FALSE;
  146.     /*
  147.      * Suggestion for flying above water by Sludge
  148.      */
  149.     if ( IS_AFFECTED( ch, AFF_FLYING ) )
  150.         found = TRUE;
  152.     for ( obj = ch->carrying; obj != NULL; obj = obj->next_content )
  153.     {
  154. if ( obj->item_type == ITEM_BOAT )
  155. {
  156.     found = TRUE;
  157.     break;
  158. }
  159.     }
  160.     if ( !found )
  161.     {
  162. send_to_char( "You need a boat to go there.nr", ch );
  163. return;
  164.     }
  165. }
  167. move = movement_loss[UMIN(SECT_MAX-1, in_room->sector_type)]
  168.      + movement_loss[UMIN(SECT_MAX-1, to_room->sector_type)]
  169.      ;
  171. if ( ch->move < move )
  172. {
  173.     send_to_char( "You are too exhausted.nr", ch );
  174.     return;
  175. }
  177. WAIT_STATE( ch, 1 );
  178. ch->move -= move;
  179.     }
  181.     if ( !IS_AFFECTED(ch, AFF_SNEAK)
  182.     && ( IS_NPC(ch) || !IS_SET(ch->act, PLR_WIZINVIS) ) )
  183. act( "$n leaves $T.", ch, NULL, dir_name[door], TO_ROOM );
  185.     char_from_room( ch );
  186.     char_to_room( ch, to_room );
  187.     if ( !IS_AFFECTED(ch, AFF_SNEAK)
  188.     && ( IS_NPC(ch) || !IS_SET(ch->act, PLR_WIZINVIS) ) )
  189. act( "$n has arrived.", ch, NULL, NULL, TO_ROOM );
  191.     do_look( ch, "auto" );
  193.     for ( fch = in_room->people; fch != NULL; fch = fch_next )
  194.     {
  195. fch_next = fch->next_in_room;
  196. if ( fch->master == ch && fch->position == POS_STANDING )
  197. {
  198.     act( "You follow $N.", fch, NULL, ch, TO_CHAR );
  199.     move_char( fch, door );
  200. }
  201.     }
  203.     mprog_entry_trigger(ch);
  204.     mprog_greet_trigger(ch);
  205.     return;
  206. }
  210. void do_north( CHAR_DATA *ch, char *argument )
  211. {
  212.     move_char( ch, DIR_NORTH );
  213.     return;
  214. }
  218. void do_east( CHAR_DATA *ch, char *argument )
  219. {
  220.     move_char( ch, DIR_EAST );
  221.     return;
  222. }
  226. void do_south( CHAR_DATA *ch, char *argument )
  227. {
  228.     move_char( ch, DIR_SOUTH );
  229.     return;
  230. }
  234. void do_west( CHAR_DATA *ch, char *argument )
  235. {
  236.     move_char( ch, DIR_WEST );
  237.     return;
  238. }
  242. void do_up( CHAR_DATA *ch, char *argument )
  243. {
  244.     move_char( ch, DIR_UP );
  245.     return;
  246. }
  250. void do_down( CHAR_DATA *ch, char *argument )
  251. {
  252.     move_char( ch, DIR_DOWN );
  253.     return;
  254. }
  258. int find_door( CHAR_DATA *ch, char *arg )
  259. {
  260.     EXIT_DATA *pexit;
  261.     int door;
  263.  if ( !str_cmp( arg, "n" ) || !str_cmp( arg, "north" ) ) door = 0;
  264.     else if ( !str_cmp( arg, "e" ) || !str_cmp( arg, "east"  ) ) door = 1;
  265.     else if ( !str_cmp( arg, "s" ) || !str_cmp( arg, "south" ) ) door = 2;
  266.     else if ( !str_cmp( arg, "w" ) || !str_cmp( arg, "west"  ) ) door = 3;
  267.     else if ( !str_cmp( arg, "u" ) || !str_cmp( arg, "up"    ) ) door = 4;
  268.     else if ( !str_cmp( arg, "d" ) || !str_cmp( arg, "down"  ) ) door = 5;
  269.     else
  270.     {
  271. for ( door = 0; door <= 5; door++ )
  272. {
  273.     if ( ( pexit = ch->in_room->exit[door] ) != NULL
  274.     &&   IS_SET(pexit->exit_info, EX_ISDOOR)
  275.     &&   pexit->keyword != NULL
  276.     &&   is_name( arg, pexit->keyword ) )
  277. return door;
  278. }
  279. act( "I see no $T here.", ch, NULL, arg, TO_CHAR );
  280. return -1;
  281.     }
  283.     if ( ( pexit = ch->in_room->exit[door] ) == NULL )
  284.     {
  285. act( "I see no door $T here.", ch, NULL, arg, TO_CHAR );
  286. return -1;
  287.     }
  289.     if ( !IS_SET(pexit->exit_info, EX_ISDOOR) )
  290.     {
  291. send_to_char( "You can't do that.nr", ch );
  292. return -1;
  293.     }
  295.     return door;
  296. }
  300. void do_open( CHAR_DATA *ch, char *argument )
  301. {
  302.     char arg[MAX_INPUT_LENGTH];
  303.     OBJ_DATA *obj;
  304.     int door;
  306.     one_argument( argument, arg );
  308.     if ( arg[0] == '' )
  309.     {
  310. send_to_char( "Open what?nr", ch );
  311. return;
  312.     }
  314.     if ( ( obj = get_obj_here( ch, arg ) ) != NULL )
  315.     {
  316. /* 'open object' */
  317. if ( obj->item_type != ITEM_CONTAINER )
  318.     { send_to_char( "That's not a container.nr", ch ); return; }
  319. if ( !IS_SET(obj->value[1], CONT_CLOSED) )
  320.     { send_to_char( "It's already open.nr",      ch ); return; }
  321. if ( !IS_SET(obj->value[1], CONT_CLOSEABLE) )
  322.     { send_to_char( "You can't do that.nr",      ch ); return; }
  323. if ( IS_SET(obj->value[1], CONT_LOCKED) )
  324.     { send_to_char( "It's locked.nr",            ch ); return; }
  326. REMOVE_BIT(obj->value[1], CONT_CLOSED);
  327. send_to_char( "Ok.nr", ch );
  328. act( "$n opens $p.", ch, obj, NULL, TO_ROOM );
  329. return;
  330.     }
  332.     if ( ( door = find_door( ch, arg ) ) >= 0 )
  333.     {
  334. /* 'open door' */
  335. ROOM_INDEX_DATA *to_room;
  336. EXIT_DATA *pexit;
  337. EXIT_DATA *pexit_rev;
  339. pexit = ch->in_room->exit[door];
  340. if ( !IS_SET(pexit->exit_info, EX_CLOSED) )
  341.     { send_to_char( "It's already open.nr",      ch ); return; }
  342. if (  IS_SET(pexit->exit_info, EX_LOCKED) )
  343.     { send_to_char( "It's locked.nr",            ch ); return; }
  345. REMOVE_BIT(pexit->exit_info, EX_CLOSED);
  346. act( "$n opens the $d.", ch, NULL, pexit->keyword, TO_ROOM );
  347. send_to_char( "Ok.nr", ch );
  349. /* open the other side */
  350. if ( ( to_room   = pexit->to_room               ) != NULL
  351. &&   ( pexit_rev = to_room->exit[rev_dir[door]] ) != NULL
  352. &&   pexit_rev->to_room == ch->in_room )
  353. {
  354.     CHAR_DATA *rch;
  356.     REMOVE_BIT( pexit_rev->exit_info, EX_CLOSED );
  357.     for ( rch = to_room->people; rch != NULL; rch = rch->next_in_room )
  358. act( "The $d opens.", rch, NULL, pexit_rev->keyword, TO_CHAR );
  359. }
  360.     }
  362.     return;
  363. }
  367. void do_close( CHAR_DATA *ch, char *argument )
  368. {
  369.     char arg[MAX_INPUT_LENGTH];
  370.     OBJ_DATA *obj;
  371.     int door;
  373.     one_argument( argument, arg );
  375.     if ( arg[0] == '' )
  376.     {
  377. send_to_char( "Close what?nr", ch );
  378. return;
  379.     }
  381.     if ( ( obj = get_obj_here( ch, arg ) ) != NULL )
  382.     {
  383. /* 'close object' */
  384. if ( obj->item_type != ITEM_CONTAINER )
  385.     { send_to_char( "That's not a container.nr", ch ); return; }
  386. if ( IS_SET(obj->value[1], CONT_CLOSED) )
  387.     { send_to_char( "It's already closed.nr",    ch ); return; }
  388. if ( !IS_SET(obj->value[1], CONT_CLOSEABLE) )
  389.     { send_to_char( "You can't do that.nr",      ch ); return; }
  391. SET_BIT(obj->value[1], CONT_CLOSED);
  392. send_to_char( "Ok.nr", ch );
  393. act( "$n closes $p.", ch, obj, NULL, TO_ROOM );
  394. return;
  395.     }
  397.     if ( ( door = find_door( ch, arg ) ) >= 0 )
  398.     {
  399. /* 'close door' */
  400. ROOM_INDEX_DATA *to_room;
  401. EXIT_DATA *pexit;
  402. EXIT_DATA *pexit_rev;
  404. pexit = ch->in_room->exit[door];
  405. if ( IS_SET(pexit->exit_info, EX_CLOSED) )
  406.     { send_to_char( "It's already closed.nr",    ch ); return; }
  408. SET_BIT(pexit->exit_info, EX_CLOSED);
  409. act( "$n closes the $d.", ch, NULL, pexit->keyword, TO_ROOM );
  410. send_to_char( "Ok.nr", ch );
  412. /* close the other side */
  413. if ( ( to_room   = pexit->to_room               ) != NULL
  414. &&   ( pexit_rev = to_room->exit[rev_dir[door]] ) != 0
  415. &&   pexit_rev->to_room == ch->in_room )
  416. {
  417.     CHAR_DATA *rch;
  419.     SET_BIT( pexit_rev->exit_info, EX_CLOSED );
  420.     for ( rch = to_room->people; rch != NULL; rch = rch->next_in_room )
  421. act( "The $d closes.", rch, NULL, pexit_rev->keyword, TO_CHAR );
  422. }
  423.     }
  425.     return;
  426. }
  430. bool has_key( CHAR_DATA *ch, int key )
  431. {
  432.     OBJ_DATA *obj;
  434.     for ( obj = ch->carrying; obj != NULL; obj = obj->next_content )
  435.     {
  436. if ( obj->pIndexData->vnum == key )
  437.     return TRUE;
  438.     }
  440.     return FALSE;
  441. }
  445. void do_lock( CHAR_DATA *ch, char *argument )
  446. {
  447.     char arg[MAX_INPUT_LENGTH];
  448.     OBJ_DATA *obj;
  449.     int door;
  451.     one_argument( argument, arg );
  453.     if ( arg[0] == '' )
  454.     {
  455. send_to_char( "Lock what?nr", ch );
  456. return;
  457.     }
  459.     if ( ( obj = get_obj_here( ch, arg ) ) != NULL )
  460.     {
  461. /* 'lock object' */
  462. if ( obj->item_type != ITEM_CONTAINER )
  463.     { send_to_char( "That's not a container.nr", ch ); return; }
  464. if ( !IS_SET(obj->value[1], CONT_CLOSED) )
  465.     { send_to_char( "It's not closed.nr",        ch ); return; }
  466. if ( obj->value[2] < 0 )
  467.     { send_to_char( "It can't be locked.nr",     ch ); return; }
  468. if ( !has_key( ch, obj->value[2] ) )
  469.     { send_to_char( "You lack the key.nr",       ch ); return; }
  470. if ( IS_SET(obj->value[1], CONT_LOCKED) )
  471.     { send_to_char( "It's already locked.nr",    ch ); return; }
  473. SET_BIT(obj->value[1], CONT_LOCKED);
  474. send_to_char( "*Click*nr", ch );
  475. act( "$n locks $p.", ch, obj, NULL, TO_ROOM );
  476. return;
  477.     }
  479.     if ( ( door = find_door( ch, arg ) ) >= 0 )
  480.     {
  481. /* 'lock door' */
  482. ROOM_INDEX_DATA *to_room;
  483. EXIT_DATA *pexit;
  484. EXIT_DATA *pexit_rev;
  486. pexit = ch->in_room->exit[door];
  487. if ( !IS_SET(pexit->exit_info, EX_CLOSED) )
  488.     { send_to_char( "It's not closed.nr",        ch ); return; }
  489. if ( pexit->key < 0 )
  490.     { send_to_char( "It can't be locked.nr",     ch ); return; }
  491. if ( !has_key( ch, pexit->key) )
  492.     { send_to_char( "You lack the key.nr",       ch ); return; }
  493. if ( IS_SET(pexit->exit_info, EX_LOCKED) )
  494.     { send_to_char( "It's already locked.nr",    ch ); return; }
  496. SET_BIT(pexit->exit_info, EX_LOCKED);
  497. send_to_char( "*Click*nr", ch );
  498. act( "$n locks the $d.", ch, NULL, pexit->keyword, TO_ROOM );
  500. /* lock the other side */
  501. if ( ( to_room   = pexit->to_room               ) != NULL
  502. &&   ( pexit_rev = to_room->exit[rev_dir[door]] ) != 0
  503. &&   pexit_rev->to_room == ch->in_room )
  504. {
  505.     SET_BIT( pexit_rev->exit_info, EX_LOCKED );
  506. }
  507.     }
  509.     return;
  510. }
  514. void do_unlock( CHAR_DATA *ch, char *argument )
  515. {
  516.     char arg[MAX_INPUT_LENGTH];
  517.     OBJ_DATA *obj;
  518.     int door;
  520.     one_argument( argument, arg );
  522.     if ( arg[0] == '' )
  523.     {
  524. send_to_char( "Unlock what?nr", ch );
  525. return;
  526.     }
  528.     if ( ( obj = get_obj_here( ch, arg ) ) != NULL )
  529.     {
  530. /* 'unlock object' */
  531. if ( obj->item_type != ITEM_CONTAINER )
  532.     { send_to_char( "That's not a container.nr", ch ); return; }
  533. if ( !IS_SET(obj->value[1], CONT_CLOSED) )
  534.     { send_to_char( "It's not closed.nr",        ch ); return; }
  535. if ( obj->value[2] < 0 )
  536.     { send_to_char( "It can't be unlocked.nr",   ch ); return; }
  537. if ( !has_key( ch, obj->value[2] ) )
  538.     { send_to_char( "You lack the key.nr",       ch ); return; }
  539. if ( !IS_SET(obj->value[1], CONT_LOCKED) )
  540.     { send_to_char( "It's already unlocked.nr",  ch ); return; }
  542. REMOVE_BIT(obj->value[1], CONT_LOCKED);
  543. send_to_char( "*Click*nr", ch );
  544. act( "$n unlocks $p.", ch, obj, NULL, TO_ROOM );
  545. return;
  546.     }
  548.     if ( ( door = find_door( ch, arg ) ) >= 0 )
  549.     {
  550. /* 'unlock door' */
  551. ROOM_INDEX_DATA *to_room;
  552. EXIT_DATA *pexit;
  553. EXIT_DATA *pexit_rev;
  555. pexit = ch->in_room->exit[door];
  556. if ( !IS_SET(pexit->exit_info, EX_CLOSED) )
  557.     { send_to_char( "It's not closed.nr",        ch ); return; }
  558. if ( pexit->key < 0 )
  559.     { send_to_char( "It can't be unlocked.nr",   ch ); return; }
  560. if ( !has_key( ch, pexit->key) )
  561.     { send_to_char( "You lack the key.nr",       ch ); return; }
  562. if ( !IS_SET(pexit->exit_info, EX_LOCKED) )
  563.     { send_to_char( "It's already unlocked.nr",  ch ); return; }
  565. REMOVE_BIT(pexit->exit_info, EX_LOCKED);
  566. send_to_char( "*Click*nr", ch );
  567. act( "$n unlocks the $d.", ch, NULL, pexit->keyword, TO_ROOM );
  569. /* unlock the other side */
  570. if ( ( to_room   = pexit->to_room               ) != NULL
  571. &&   ( pexit_rev = to_room->exit[rev_dir[door]] ) != NULL
  572. &&   pexit_rev->to_room == ch->in_room )
  573. {
  574.     REMOVE_BIT( pexit_rev->exit_info, EX_LOCKED );
  575. }
  576.     }
  578.     return;
  579. }
  583. void do_pick( CHAR_DATA *ch, char *argument )
  584. {
  585.     char arg[MAX_INPUT_LENGTH];
  586.     CHAR_DATA *gch;
  587.     OBJ_DATA *obj;
  588.     int door;
  590.     one_argument( argument, arg );
  592.     if ( arg[0] == '' )
  593.     {
  594. send_to_char( "Pick what?nr", ch );
  595. return;
  596.     }
  598.     WAIT_STATE( ch, skill_table[gsn_pick_lock].beats );
  600.     /* look for guards */
  601.     for ( gch = ch->in_room->people; gch; gch = gch->next_in_room )
  602.     {
  603. if ( IS_NPC(gch) && IS_AWAKE(gch) && ch->level + 5 < gch->level )
  604. {
  605.     act( "$N is standing too close to the lock.",
  606. ch, NULL, gch, TO_CHAR );
  607.     return;
  608. }
  609.     }
  611.     if ( !IS_NPC(ch) && number_percent( ) > ch->pcdata->learned[gsn_pick_lock] )
  612.     {
  613. send_to_char( "You failed.nr", ch);
  614. return;
  615.     }
  617.     if ( ( obj = get_obj_here( ch, arg ) ) != NULL )
  618.     {
  619. /* 'pick object' */
  620. if ( obj->item_type != ITEM_CONTAINER )
  621.     { send_to_char( "That's not a container.nr", ch ); return; }
  622. if ( !IS_SET(obj->value[1], CONT_CLOSED) )
  623.     { send_to_char( "It's not closed.nr",        ch ); return; }
  624. if ( obj->value[2] < 0 )
  625.     { send_to_char( "It can't be unlocked.nr",   ch ); return; }
  626. if ( !IS_SET(obj->value[1], CONT_LOCKED) )
  627.     { send_to_char( "It's already unlocked.nr",  ch ); return; }
  628. if ( IS_SET(obj->value[1], CONT_PICKPROOF) )
  629.     { send_to_char( "You failed.nr",             ch ); return; }
  631. REMOVE_BIT(obj->value[1], CONT_LOCKED);
  632. send_to_char( "*Click*nr", ch );
  633. act( "$n picks $p.", ch, obj, NULL, TO_ROOM );
  634. return;
  635.     }
  637.     if ( ( door = find_door( ch, arg ) ) >= 0 )
  638.     {
  639. /* 'pick door' */
  640. ROOM_INDEX_DATA *to_room;
  641. EXIT_DATA *pexit;
  642. EXIT_DATA *pexit_rev;
  644. pexit = ch->in_room->exit[door];
  645. if ( !IS_SET(pexit->exit_info, EX_CLOSED) )
  646.     { send_to_char( "It's not closed.nr",        ch ); return; }
  647. if ( pexit->key < 0 )
  648.     { send_to_char( "It can't be picked.nr",     ch ); return; }
  649. if ( !IS_SET(pexit->exit_info, EX_LOCKED) )
  650.     { send_to_char( "It's already unlocked.nr",  ch ); return; }
  651. if ( IS_SET(pexit->exit_info, EX_PICKPROOF) )
  652.     { send_to_char( "You failed.nr",             ch ); return; }
  654. REMOVE_BIT(pexit->exit_info, EX_LOCKED);
  655. send_to_char( "*Click*nr", ch );
  656. act( "$n picks the $d.", ch, NULL, pexit->keyword, TO_ROOM );
  658. /* pick the other side */
  659. if ( ( to_room   = pexit->to_room               ) != NULL
  660. &&   ( pexit_rev = to_room->exit[rev_dir[door]] ) != NULL
  661. &&   pexit_rev->to_room == ch->in_room )
  662. {
  663.     REMOVE_BIT( pexit_rev->exit_info, EX_LOCKED );
  664. }
  665.     }
  667.     return;
  668. }
  673. void do_stand( CHAR_DATA *ch, char *argument )
  674. {
  675.     switch ( ch->position )
  676.     {
  677.     case POS_SLEEPING:
  678. if ( IS_AFFECTED(ch, AFF_SLEEP) )
  679.     { send_to_char( "You can't wake up!nr", ch ); return; }
  681. send_to_char( "You wake and stand up.nr", ch );
  682. act( "$n wakes and stands up.", ch, NULL, NULL, TO_ROOM );
  683. ch->position = POS_STANDING;
  684. break;
  686.     case POS_RESTING:
  687. send_to_char( "You stand up.nr", ch );
  688. act( "$n stands up.", ch, NULL, NULL, TO_ROOM );
  689. ch->position = POS_STANDING;
  690. break;
  692.     case POS_STANDING:
  693. send_to_char( "You are already standing.nr", ch );
  694. break;
  696.     case POS_FIGHTING:
  697. send_to_char( "You are already fighting!nr", ch );
  698. break;
  699.     }
  701.     return;
  702. }
  706. void do_rest( CHAR_DATA *ch, char *argument )
  707. {
  708.     switch ( ch->position )
  709.     {
  710.     case POS_SLEEPING:
  711. send_to_char( "You are already sleeping.nr", ch );
  712. break;
  714.     case POS_RESTING:
  715. send_to_char( "You are already resting.nr", ch );
  716. break;
  718.     case POS_STANDING:
  719. send_to_char( "You rest.nr", ch );
  720. act( "$n rests.", ch, NULL, NULL, TO_ROOM );
  721. ch->position = POS_RESTING;
  722. break;
  724.     case POS_FIGHTING:
  725. send_to_char( "You are already fighting!nr", ch );
  726. break;
  727.     }
  729.     return;
  730. }
  734. void do_sleep( CHAR_DATA *ch, char *argument )
  735. {
  736.     switch ( ch->position )
  737.     {
  738.     case POS_SLEEPING:
  739. send_to_char( "You are already sleeping.nr", ch );
  740. break;
  742.     case POS_RESTING:
  743.     case POS_STANDING: 
  744. send_to_char( "You sleep.nr", ch );
  745. act( "$n sleeps.", ch, NULL, NULL, TO_ROOM );
  746. ch->position = POS_SLEEPING;
  747. break;
  749.     case POS_FIGHTING:
  750. send_to_char( "You are already fighting!nr", ch );
  751. break;
  752.     }
  754.     return;
  755. }
  759. void do_wake( CHAR_DATA *ch, char *argument )
  760. {
  761.     char arg[MAX_INPUT_LENGTH];
  762.     CHAR_DATA *victim;
  764.     one_argument( argument, arg );
  765.     if ( arg[0] == '' )
  766. { do_stand( ch, argument ); return; }
  768.     if ( !IS_AWAKE(ch) )
  769. { send_to_char( "You are asleep yourself!nr",       ch ); return; }
  771.     if ( ( victim = get_char_room( ch, arg ) ) == NULL )
  772. { send_to_char( "They aren't here.nr",              ch ); return; }
  774.     if ( IS_AWAKE(victim) )
  775. { act( "$N is already awake.", ch, NULL, victim, TO_CHAR ); return; }
  777.     if ( IS_AFFECTED(victim, AFF_SLEEP) )
  778. { act( "You can't wake $M!",   ch, NULL, victim, TO_CHAR );  return; }
  780.     act( "You wake $M.", ch, NULL, victim, TO_CHAR );
  781.     act( "$n wakes you.", ch, NULL, victim, TO_VICT );
  782.     victim->position = POS_STANDING;
  783.     return;
  784. }
  788. void do_sneak( CHAR_DATA *ch, char *argument )
  789. {
  790.     AFFECT_DATA af;
  792.     send_to_char( "You attempt to move silently.nr", ch );
  793.     affect_strip( ch, gsn_sneak );
  795.     if ( IS_NPC(ch) || number_percent( ) < ch->pcdata->learned[gsn_sneak] )
  796.     {
  797. af.type      = gsn_sneak;
  798. af.duration  = ch->level;
  799. af.location  = APPLY_NONE;
  800. af.modifier  = 0;
  801. af.bitvector = AFF_SNEAK;
  802. affect_to_char( ch, &af );
  803.     }
  805.     return;
  806. }
  810. void do_hide( CHAR_DATA *ch, char *argument )
  811. {
  812.     send_to_char( "You attempt to hide.nr", ch );
  814.     if ( IS_AFFECTED(ch, AFF_HIDE) )
  815. REMOVE_BIT(ch->affected_by, AFF_HIDE);
  817.     if ( IS_NPC(ch) || number_percent( ) < ch->pcdata->learned[gsn_hide] )
  818. SET_BIT(ch->affected_by, AFF_HIDE);
  820.     return;
  821. }
  825. /*
  826.  * Contributed by Alander.
  827.  */
  828. void do_visible( CHAR_DATA *ch, char *argument )
  829. {
  830.     affect_strip ( ch, gsn_invis );
  831.     affect_strip ( ch, gsn_mass_invis );
  832.     affect_strip ( ch, gsn_sneak );
  833.     REMOVE_BIT   ( ch->affected_by, AFF_HIDE );
  834.     REMOVE_BIT   ( ch->affected_by, AFF_INVISIBLE );
  835.     REMOVE_BIT   ( ch->affected_by, AFF_SNEAK );
  836.     send_to_char( "Ok.nr", ch );
  837.     return;
  838. }
  841. void do_recall( CHAR_DATA *ch, char *argument )
  842. {
  843.     char buf[MAX_STRING_LENGTH];
  844.     CHAR_DATA *victim;
  845.     ROOM_INDEX_DATA *location;
  846.   
  847.     act( "$n prays for transportation!", ch, 0, 0, TO_ROOM );
  849. //    if ( ( location = get_room_index( ROOM_VNUM_TEMPLE ) ) == NULL )
  850.     if ( ( location = get_room_index( race_table[ch->race].city_temple ) ) == NULL )
  851.     {
  852. send_to_char( "You are completely lost.nr", ch );
  853. return;
  854.     }
  856.     if ( ch->in_room == location )
  857. return;
  859.     if ( IS_SET(ch->in_room->room_flags, ROOM_NO_RECALL)
  860.     ||   IS_AFFECTED(ch, AFF_CURSE) )
  861.     {
  862. send_to_char( "God has forsaken you.nr", ch );
  863. return;
  864.     }
  866.     if ( ( victim = ch->fighting ) != NULL )
  867.     {
  868. int lose;
  870. if ( number_bits( 1 ) == 0 )
  871. {
  872.     WAIT_STATE( ch, 4 );
  873.     lose = (ch->desc != NULL) ? 50 : 100;
  874.     gain_exp( ch, 0 - lose );
  875.     sprintf( buf, "You failed!  You lose %d exps.nr", lose );
  876.     send_to_char( buf, ch );
  877.     return;
  878. }
  880. lose = (ch->desc != NULL) ? 100 : 200;
  881. gain_exp( ch, 0 - lose );
  882. sprintf( buf, "You recall from combat!  You lose %d exps.nr", lose );
  883. send_to_char( buf, ch );
  884. stop_fighting( ch, TRUE );
  885.     }
  887.     ch->move /= 2;
  888.     act( "$n disappears.", ch, NULL, NULL, TO_ROOM );
  889.     char_from_room( ch );
  890.     char_to_room( ch, location );
  891.     act( "$n appears in the room.", ch, NULL, NULL, TO_ROOM );
  892.     do_look( ch, "auto" );
  894.     return;
  895. }
  897. /*    { "identify", do_identify, POS_STANDING,  0,  LOG_NORMAL   }, */
  899. #define MOB_VNUM_SAGE    8911
  900. void do_identify( CHAR_DATA *ch, char *argument )
  901. {
  902.     OBJ_DATA *obj;
  903.     CHAR_DATA *rch;
  905.     if ( ( obj = get_obj_carry( ch, argument ) ) == NULL )
  906.     {
  907.        send_to_char( "You are not carrying that.nr", ch );
  908.        return;
  909.     }
  911.     for ( rch = ch->in_room->people; rch != NULL; rch = rch->next_in_room )
  912.        if (IS_NPC(rch) && rch->pIndexData->vnum == MOB_VNUM_SAGE)
  913.           break;
  915.     if (!rch)
  916.     {
  917.        send_to_char("No one here seems to know much about that.nr", ch);
  918.        return;
  919.     }
  921.     if (IS_IMMORTAL(ch))
  922.        act( "$n cackles and comps you!nr", rch, obj, ch, TO_VICT );
  923.     else if (ch->gold < obj->level * 100 + 50)
  924.        {
  925.        act( "$n resumes tossing bones without looking at $p.",
  926.              rch, obj, 0, TO_ROOM );
  927.        return;
  928.        }
  929.     else
  930.        {
  931.        ch->gold -= obj->level * 100 + 50;
  932.        send_to_char("Your purse feels lighter.nr", ch);
  933.        }
  935.     act( "$n fondles $p and tosses some chicken bones to the ground.",
  936.        rch, obj, 0, TO_ROOM );
  937.     spell_identify( 0, 0, ch, obj );
  938. }
  942. void do_train( CHAR_DATA *ch, char *argument )
  943. {
  944.     char buf[MAX_STRING_LENGTH];
  945.     CHAR_DATA *mob;
  946.     int hp_gain = 0;
  947.     int mana_gain = 0;
  948.     sh_int *pAbility;
  949.     char *pOutput;
  950.     int cost;
  952.     if ( IS_NPC(ch) )
  953. return;
  955.     /*
  956.      * Check for trainer.
  957.      */
  958.     for ( mob = ch->in_room->people; mob; mob = mob->next_in_room )
  959.     {
  960. if ( IS_NPC(mob) && IS_SET(mob->act, ACT_TRAIN) )
  961.     break;
  962.     }
  964.     if ( mob == NULL )
  965.     {
  966. send_to_char( "You can't do that here.nr", ch );
  967. return;
  968.     }
  970.     if ( argument[0] == '' )
  971.     {
  972. sprintf( buf, "You have %d practice sessions.nr", ch->practice );
  973. send_to_char( buf, ch );
  974. argument = "foo";
  975.     }
  977.     cost = 5;
  979.     if ( !str_cmp( argument, "str" ) )
  980.     {
  981. if ( class_table[ch->class].attr_prime == APPLY_STR )
  982.     cost    = 3;
  983. pAbility    = &ch->pcdata->perm_str;
  984. pOutput     = "strength";
  985.     }
  987.     else if ( !str_cmp( argument, "int" ) )
  988.     {
  989. if ( class_table[ch->class].attr_prime == APPLY_INT )
  990.     cost    = 3;
  991. pAbility    = &ch->pcdata->perm_int;
  992. pOutput     = "intelligence";
  993.     }
  995.     else if ( !str_cmp( argument, "wis" ) )
  996.     {
  997. if ( class_table[ch->class].attr_prime == APPLY_WIS )
  998.     cost    = 3;
  999. pAbility    = &ch->pcdata->perm_wis;
  1000. pOutput     = "wisdom";
  1001.     }
  1003.     else if ( !str_cmp( argument, "dex" ) )
  1004.     {
  1005. if ( class_table[ch->class].attr_prime == APPLY_DEX )
  1006.     cost    = 3;
  1007. pAbility    = &ch->pcdata->perm_dex;
  1008. pOutput     = "dexterity";
  1009.     }
  1011.     else if ( !str_cmp( argument, "con" ) )
  1012.     {
  1013. if ( class_table[ch->class].attr_prime == APPLY_CON )
  1014.     cost    = 3;
  1015. pAbility    = &ch->pcdata->perm_con;
  1016. pOutput     = "constitution";
  1017.     }
  1019.     else if ( !str_cmp( argument, "hp" ) )
  1020.       {
  1021.         pAbility = &ch->max_hit;
  1022.         pOutput = "number of hit points";
  1023.         cost = 1;    /* this is pracs per "train hp" */
  1024.         hp_gain = 2; /* this is hp gained per "train hp" */
  1025.       }
  1026.  
  1027.     else if ( !str_cmp( argument, "mana" ) )
  1028.       {
  1029.         pAbility = &ch->max_mana;
  1030.         pOutput = "amount of mana";
  1031.         cost =1;
  1032.         mana_gain = 3;
  1033.       }
  1035.     else
  1036.     {
  1037.    strcpy( buf, "You can train: hp mana" );
  1038. if ( ch->pcdata->perm_str < 18 ) strcat( buf, " str" );
  1039. if ( ch->pcdata->perm_int < 18 ) strcat( buf, " int" );
  1040. if ( ch->pcdata->perm_wis < 18 ) strcat( buf, " wis" );
  1041. if ( ch->pcdata->perm_dex < 18 ) strcat( buf, " dex" );
  1042. if ( ch->pcdata->perm_con < 18 ) strcat( buf, " con" );
  1044. // if ( buf[strlen(buf)-1] != ':' )
  1045. // {
  1046.     strcat( buf, ".nr" );
  1047.     send_to_char( buf, ch );
  1048. // }
  1049. // else
  1050. // {
  1051. //     /*
  1052. //      * This message dedicated to Jordan ... you big stud!
  1053. //      */
  1054. //     act( "You have nothing left to train, you $T!",
  1055. // ch, NULL,
  1056. // ch->sex == SEX_MALE   ? "big stud" :
  1057. // ch->sex == SEX_FEMALE ? "hot babe" :
  1058. // "wild thing",
  1059. // TO_CHAR );
  1060. // }
  1062. return;
  1063.     }
  1065.     if ( !str_cmp( argument, "hp" ) )
  1066.       {
  1067.       
  1068.         if ( cost > ch->practice )
  1069.   {
  1070.             send_to_char( "You don't have enough practices.nr", ch );
  1071.             return;
  1072.   }
  1074.              ch->practice        -= cost;
  1075.              *pAbility           += hp_gain;
  1076.              act( "Your $T increases!", ch, NULL, pOutput, TO_CHAR );
  1077.              act( "$n's $T increases!", ch, NULL, pOutput, TO_ROOM );
  1078.              return;
  1079.       }
  1081. if ( !str_cmp( argument, "mana" ) )
  1082.   {
  1084.         if ( cost > ch->practice )
  1085.   {
  1086.             send_to_char( "You don't have enough practices.nr", ch );
  1087.             return;
  1088.   }
  1090.              ch->practice        -= cost;
  1091.              *pAbility           += mana_gain;
  1092.              act( "Your $T increases!", ch, NULL, pOutput, TO_CHAR );
  1093.              act( "$n's $T increases!", ch, NULL, pOutput, TO_ROOM );
  1094.              return;
  1095.       }
  1096.     if ( *pAbility >= 18 )
  1097.     {
  1098. act( "Your $T is already at maximum.", ch, NULL, pOutput, TO_CHAR );
  1099. return;
  1100.     }
  1102.     if ( cost > ch->practice )
  1103.     {
  1104. send_to_char( "You don't have enough practices.nr", ch );
  1105. return;
  1106.     }
  1108.     ch->practice -= cost;
  1109.     *pAbility += 1;
  1110.     act( "Your $T increases!", ch, NULL, pOutput, TO_CHAR );
  1111.     act( "$n's $T increases!", ch, NULL, pOutput, TO_ROOM );
  1112.     return;
  1113. }