/***************************************************************************
* Original Diku Mud copyright (C) 1990, 1991 by Sebastian Hammer, *
* Michael Seifert, Hans Henrik St{rfeldt, Tom Madsen, and Katja Nyboe. *
* *
* Merc Diku Mud improvments copyright (C) 1992, 1993 by Michael *
* Chastain, Michael Quan, and Mitchell Tse. *
* *
* In order to use any part of this Merc Diku Mud, you must comply with *
* both the original Diku license in 'license.doc' as well the Merc *
* license in 'license.txt'. In particular, you may not remove either of *
* these copyright notices. *
* *
* Much time and thought has gone into this software and you are *
* benefitting. We hope that you share your changes too. What goes *
* around, comes around. *
***************************************************************************/
#if defined(macintosh)
#include <types.h>
#include <time.h>
#else
#include <sys/types.h>
#include <sys/time.h>
#endif
#include <stdio.h>
#include <string.h>
#include "merc.h"
/* Utility macros for track*/
#define MARK(room) (SET_BIT((room)->room_flags, ROOM_MARK))
#define UNMARK(room) (REMOVE_BIT((room)->room_flags, ROOM_MARK))
#define IS_MARKED(room) (IS_SET((room)->room_flags, ROOM_MARK))
#define TOROOM(x, y) ((x)->exit[(y)] ? (x)->exit[(y)]->u1.to_room : NULL)
#define IS_CLOSED(x, y) (IS_SET((x)->exit[(y)]->exit_info, EX_CLOSED))
#define IS_SAME_AREA(x,y) ((x)->area == (y)->area)
#ifdef TRACK_THROUGH_DOORS
#define VALID_EDGE(x, y) ((x)->exit[(y)] && \
(TOROOM((x), (y)) != NULL) && \
(!IS_MARKED(TOROOM((x), (y)))) && \
(IS_SAME_AREA((x), TOROOM((x),(y)))))
#else
#define VALID_EDGE(x, y) ((x)->exit[(y)] && \
(TOROOM((x), (y)) != NULL) && \
(!IS_CLOSED((x), (y))) && \
(!IS_MARKED(TOROOM((x), (y)))) && \
(IS_SAME_AREA((x), TOROOM((x),(y)))))
#endif
struct track_queue_struct
{
ROOM_INDEX_DATA *room;
char dir;
struct track_queue_struct *next;
};
static struct track_queue_struct *queue_head = NULL, *queue_tail = NULL;
/* end track */
/* command procedures needed */
DECLARE_DO_FUN(do_look );
DECLARE_DO_FUN(do_recall );
DECLARE_DO_FUN(do_stand );
char * const dir_name [] =
{
"north", "east", "south", "west", "up", "down"
};
const sh_int rev_dir [] =
{
2, 3, 0, 1, 5, 4
};
const sh_int movement_loss [SECT_MAX] =
{
1, 2, 2, 3, 4, 6, 4, 1, 6, 10, 6
};
/*
* Local functions.
*/
int find_door args( ( CHAR_DATA *ch, char *arg ) );
bool has_key args( ( CHAR_DATA *ch, int key ) );
bool check_web args( ( CHAR_DATA *ch) );
void move_char( CHAR_DATA *ch, int door, bool follow )
{
CHAR_DATA *fch;
CHAR_DATA *fch_next;
ROOM_INDEX_DATA *in_room;
ROOM_INDEX_DATA *to_room;
EXIT_DATA *pexit;
if ( door < 0 || door > 5 )
{
bug( "Do_move: bad door %d.", door );
return;
}
if (IS_AFFECTED(ch, AFF_WEB))
{
if (check_web(ch))
{
act( "You break free of the webs and fall down from the effort.", ch, NULL, NULL, TO_CHAR );
act( "$n breaks free of the webs and falls downs from the effort.", ch, NULL,NULL,TO_ROOM);
WAIT_STATE( ch, 5 );
ch->move -= 5;
affect_strip(ch,skill_lookup("web"));
REMOVE_BIT( ch->affected_by, AFF_WEB);
ch->position = POS_RESTING;
return;
}
else
{
act( "You struggle against the webs.", ch, NULL, NULL, TO_CHAR );
act( "$n struggles weakly in the webs.", ch, NULL,NULL,TO_ROOM);
WAIT_STATE( ch, 5 );
ch->move -= 5;
return;
}
/* The end? */
}
in_room = ch->in_room;
if ( ( pexit = in_room->exit[door] ) == NULL
|| ( to_room = pexit->u1.to_room ) == NULL
|| !can_see_room(ch,pexit->u1.to_room))
{
send_to_char( "Alas, you cannot go that way.\n\r", ch );
return;
}
if ( IS_SET(pexit->exit_info, EX_CLOSED)
&& IS_SET(pexit->exit_info, EX_HIDDEN))
{
send_to_char( "Alas, you cannot go that way.\n\r", ch );
return;
}
if ( IS_SET(pexit->exit_info, EX_CLOSED)
&& !IS_AFFECTED(ch, AFF_PASS_DOOR) )
{
act( "The $d is closed.", ch, NULL, pexit->keyword, TO_CHAR );
act( "$n tries unsuccessfully to walk through the $d.", ch, NULL, pexit->keyword, TO_ROOM );
return;
}
if ( IS_SET(pexit->exit_info, EX_CLOSED)
&& IS_SET(pexit->exit_info, EX_PASSPROOF)
&& IS_AFFECTED(ch, AFF_PASS_DOOR) )
{
act( "A magical force prevents you from passing through the $d.", ch, NULL, pexit->keyword, TO_CHAR );
act( "$n looks puzzled by not passing through the $d.", ch, NULL, pexit->keyword, TO_ROOM );
return;
}
if ( IS_AFFECTED(ch, AFF_CHARM)
&& ch->master != NULL
&& in_room == ch->master->in_room )
{
send_to_char( "What? And leave your beloved master?\n\r", ch );
return;
}
if ( room_is_private( to_room ) )
{
send_to_char( "That room is private right now.\n\r", ch );
return;
}
if ( !IS_NPC(ch) )
{
int iClass, iGuild;
int move;
for ( iClass = 0; iClass < MAX_CLASS; iClass++ )
{
for ( iGuild = 0; iGuild < MAX_GUILD; iGuild ++)
{
if ( iClass != ch->class
&& to_room->vnum == class_table[iClass].guild[iGuild] )
{
send_to_char( "You aren't allowed in there.\n\r", ch );
return;
}
}
}
if ( in_room->sector_type == SECT_AIR
|| to_room->sector_type == SECT_AIR )
{
if ( !IS_AFFECTED(ch, AFF_FLYING) && !IS_IMMORTAL(ch))
{
send_to_char( "You can't fly.\n\r", ch );
return;
}
}
if (( in_room->sector_type == SECT_WATER_NOSWIM
|| to_room->sector_type == SECT_WATER_NOSWIM )
&& !IS_AFFECTED(ch,AFF_FLYING))
{
OBJ_DATA *obj;
bool found;
/*
* Look for a boat.
*/
found = FALSE;
if (IS_IMMORTAL(ch))
found = TRUE;
for ( obj = ch->carrying; obj != NULL; obj = obj->next_content )
{
if ( obj->item_type == ITEM_BOAT )
{
found = TRUE;
break;
}
}
if ( !found )
{
send_to_char( "You need a boat to go there.\n\r", ch );
return;
}
}
move = movement_loss[UMIN(SECT_MAX-1, in_room->sector_type)]
+ movement_loss[UMIN(SECT_MAX-1, to_room->sector_type)]
;
move /= 2; /* i.e. the average */
if ( ch->move < move )
{
send_to_char( "You are too exhausted.\n\r", ch );
return;
}
WAIT_STATE( ch, 1 );
ch->move -= move;
}
if ( !IS_AFFECTED(ch, AFF_SNEAK)
&& ( IS_NPC(ch) || !IS_SET(ch->act, PLR_WIZINVIS) ) )
act( "$n leaves $T.", ch, NULL, dir_name[door], TO_ROOM );
char_from_room( ch );
char_to_room( ch, to_room );
if ( !IS_AFFECTED(ch, AFF_SNEAK)
&& ( IS_NPC(ch) || !IS_SET(ch->act, PLR_WIZINVIS) ) )
act( "$n has arrived.", ch, NULL, NULL, TO_ROOM );
do_look( ch, "auto" );
if (in_room == to_room) /* no circular follows */
return;
for ( fch = in_room->people; fch != NULL; fch = fch_next )
{
fch_next = fch->next_in_room;
if ( fch->master == ch && IS_AFFECTED(fch,AFF_CHARM)
&& fch->position < POS_STANDING)
do_stand(fch,"");
if ( fch->master == ch && fch->position == POS_STANDING )
{
if (IS_SET(ch->in_room->room_flags,ROOM_LAW)
&& (IS_NPC(fch) && IS_SET(fch->act,ACT_AGGRESSIVE)))
{
act("You can't bring $N into the city.",
ch,NULL,fch,TO_CHAR);
act("You aren't allowed in the city.",
fch,NULL,NULL,TO_CHAR);
return;
}
act( "You follow $N.", fch, NULL, ch, TO_CHAR );
move_char( fch, door, TRUE );
}
}
mprog_entry_trigger( ch );
mprog_greet_trigger( ch );
return;
}
void do_north( CHAR_DATA *ch, char *argument )
{
move_char( ch, DIR_NORTH, FALSE );
return;
}
void do_east( CHAR_DATA *ch, char *argument )
{
move_char( ch, DIR_EAST, FALSE );
return;
}
void do_south( CHAR_DATA *ch, char *argument )
{
move_char( ch, DIR_SOUTH, FALSE );
return;
}
void do_west( CHAR_DATA *ch, char *argument )
{
move_char( ch, DIR_WEST, FALSE );
return;
}
void do_up( CHAR_DATA *ch, char *argument )
{
move_char( ch, DIR_UP, FALSE );
return;
}
void do_down( CHAR_DATA *ch, char *argument )
{
move_char( ch, DIR_DOWN, FALSE );
return;
}
int find_door( CHAR_DATA *ch, char *arg )
{
EXIT_DATA *pexit;
int door;
if ( !str_cmp( arg, "n" ) || !str_cmp( arg, "north" ) ) door = 0;
else if ( !str_cmp( arg, "e" ) || !str_cmp( arg, "east" ) ) door = 1;
else if ( !str_cmp( arg, "s" ) || !str_cmp( arg, "south" ) ) door = 2;
else if ( !str_cmp( arg, "w" ) || !str_cmp( arg, "west" ) ) door = 3;
else if ( !str_cmp( arg, "u" ) || !str_cmp( arg, "up" ) ) door = 4;
else if ( !str_cmp( arg, "d" ) || !str_cmp( arg, "down" ) ) door = 5;
else
{
for ( door = 0; door <= 5; door++ )
{
if ( ( pexit = ch->in_room->exit[door] ) != NULL
&& IS_SET(pexit->exit_info, EX_ISDOOR)
&& pexit->keyword != NULL
&& is_name( arg, pexit->keyword ) )
return door;
}
act( "I see no $T here.", ch, NULL, arg, TO_CHAR );
return -1;
}
if ( ( pexit = ch->in_room->exit[door] ) == NULL )
{
act( "I see no door $T here.", ch, NULL, arg, TO_CHAR );
return -1;
}
if ( !IS_SET(pexit->exit_info, EX_ISDOOR) )
{
send_to_char( "You can't do that.\n\r", ch );
return -1;
}
return door;
}
void do_open( CHAR_DATA *ch, char *argument )
{
char arg[MAX_INPUT_LENGTH];
OBJ_DATA *obj;
int door;
one_argument( argument, arg );
if ( arg[0] == '\0' )
{
send_to_char( "Open what?\n\r", ch );
return;
}
if ( ( obj = get_obj_here( ch, arg ) ) != NULL )
{
/* 'open object' */
if ( obj->item_type != ITEM_CONTAINER )
{ send_to_char( "That's not a container.\n\r", ch ); return; }
if ( !IS_SET(obj->value[1], CONT_CLOSED) )
{ send_to_char( "It's already open.\n\r", ch ); return; }
if ( !IS_SET(obj->value[1], CONT_CLOSEABLE) )
{ send_to_char( "You can't do that.\n\r", ch ); return; }
if ( IS_SET(obj->value[1], CONT_LOCKED) )
{ send_to_char( "It's locked.\n\r", ch ); return; }
REMOVE_BIT(obj->value[1], CONT_CLOSED);
send_to_char( "Ok.\n\r", ch );
act( "$n opens $p.", ch, obj, NULL, TO_ROOM );
return;
}
if ( ( door = find_door( ch, arg ) ) >= 0 )
{
/* 'open door' */
ROOM_INDEX_DATA *to_room;
EXIT_DATA *pexit;
EXIT_DATA *pexit_rev;
pexit = ch->in_room->exit[door];
if ( !IS_SET(pexit->exit_info, EX_CLOSED) )
{ send_to_char( "It's already open.\n\r", ch ); return; }
if ( IS_SET(pexit->exit_info, EX_LOCKED) )
{ send_to_char( "It's locked.\n\r", ch ); return; }
REMOVE_BIT(pexit->exit_info, EX_CLOSED);
act( "$n opens the $d.", ch, NULL, pexit->keyword, TO_ROOM );
send_to_char( "Ok.\n\r", ch );
/* open the other side */
if ( ( to_room = pexit->u1.to_room ) != NULL
&& ( pexit_rev = to_room->exit[rev_dir[door]] ) != NULL
&& pexit_rev->u1.to_room == ch->in_room )
{
CHAR_DATA *rch;
REMOVE_BIT( pexit_rev->exit_info, EX_CLOSED );
for ( rch = to_room->people; rch != NULL; rch = rch->next_in_room )
act( "The $d opens.", rch, NULL, pexit_rev->keyword, TO_CHAR );
}
}
return;
}
void do_close( CHAR_DATA *ch, char *argument )
{
char arg[MAX_INPUT_LENGTH];
OBJ_DATA *obj;
int door;
one_argument( argument, arg );
if ( arg[0] == '\0' )
{
send_to_char( "Close what?\n\r", ch );
return;
}
if ( ( obj = get_obj_here( ch, arg ) ) != NULL )
{
/* 'close object' */
if ( obj->item_type != ITEM_CONTAINER )
{ send_to_char( "That's not a container.\n\r", ch ); return; }
if ( IS_SET(obj->value[1], CONT_CLOSED) )
{ send_to_char( "It's already closed.\n\r", ch ); return; }
if ( !IS_SET(obj->value[1], CONT_CLOSEABLE) )
{ send_to_char( "You can't do that.\n\r", ch ); return; }
SET_BIT(obj->value[1], CONT_CLOSED);
send_to_char( "Ok.\n\r", ch );
act( "$n closes $p.", ch, obj, NULL, TO_ROOM );
return;
}
if ( ( door = find_door( ch, arg ) ) >= 0 )
{
/* 'close door' */
ROOM_INDEX_DATA *to_room;
EXIT_DATA *pexit;
EXIT_DATA *pexit_rev;
pexit = ch->in_room->exit[door];
if ( IS_SET(pexit->exit_info, EX_CLOSED) )
{ send_to_char( "It's already closed.\n\r", ch ); return; }
SET_BIT(pexit->exit_info, EX_CLOSED);
act( "$n closes the $d.", ch, NULL, pexit->keyword, TO_ROOM );
send_to_char( "Ok.\n\r", ch );
/* close the other side */
if ( ( to_room = pexit->u1.to_room ) != NULL
&& ( pexit_rev = to_room->exit[rev_dir[door]] ) != 0
&& pexit_rev->u1.to_room == ch->in_room )
{
CHAR_DATA *rch;
SET_BIT( pexit_rev->exit_info, EX_CLOSED );
for ( rch = to_room->people; rch != NULL; rch = rch->next_in_room )
act( "The $d closes.", rch, NULL, pexit_rev->keyword, TO_CHAR );
}
}
return;
}
bool has_key( CHAR_DATA *ch, int key )
{
OBJ_DATA *obj;
for ( obj = ch->carrying; obj != NULL; obj = obj->next_content )
{
if ( obj->pIndexData->vnum == key )
return TRUE;
}
return FALSE;
}
void do_lock( CHAR_DATA *ch, char *argument )
{
char arg[MAX_INPUT_LENGTH];
OBJ_DATA *obj;
int door;
one_argument( argument, arg );
if ( arg[0] == '\0' )
{
send_to_char( "Lock what?\n\r", ch );
return;
}
if ( ( obj = get_obj_here( ch, arg ) ) != NULL )
{
/* 'lock object' */
if ( obj->item_type != ITEM_CONTAINER )
{ send_to_char( "That's not a container.\n\r", ch ); return; }
if ( !IS_SET(obj->value[1], CONT_CLOSED) )
{ send_to_char( "It's not closed.\n\r", ch ); return; }
if ( obj->value[2] < 0 )
{ send_to_char( "It can't be locked.\n\r", ch ); return; }
if ( !has_key( ch, obj->value[2] ) )
{ send_to_char( "You lack the key.\n\r", ch ); return; }
if ( IS_SET(obj->value[1], CONT_LOCKED) )
{ send_to_char( "It's already locked.\n\r", ch ); return; }
SET_BIT(obj->value[1], CONT_LOCKED);
send_to_char( "*Click*\n\r", ch );
act( "$n locks $p.", ch, obj, NULL, TO_ROOM );
return;
}
if ( ( door = find_door( ch, arg ) ) >= 0 )
{
/* 'lock door' */
ROOM_INDEX_DATA *to_room;
EXIT_DATA *pexit;
EXIT_DATA *pexit_rev;
pexit = ch->in_room->exit[door];
if ( !IS_SET(pexit->exit_info, EX_CLOSED) )
{ send_to_char( "It's not closed.\n\r", ch ); return; }
if ( pexit->key < 0 )
{ send_to_char( "It can't be locked.\n\r", ch ); return; }
if ( !has_key( ch, pexit->key) )
{ send_to_char( "You lack the key.\n\r", ch ); return; }
if ( IS_SET(pexit->exit_info, EX_LOCKED) )
{ send_to_char( "It's already locked.\n\r", ch ); return; }
SET_BIT(pexit->exit_info, EX_LOCKED);
send_to_char( "*Click*\n\r", ch );
act( "$n locks the $d.", ch, NULL, pexit->keyword, TO_ROOM );
/* lock the other side */
if ( ( to_room = pexit->u1.to_room ) != NULL
&& ( pexit_rev = to_room->exit[rev_dir[door]] ) != 0
&& pexit_rev->u1.to_room == ch->in_room )
{
SET_BIT( pexit_rev->exit_info, EX_LOCKED );
}
}
return;
}
void do_unlock( CHAR_DATA *ch, char *argument )
{
char arg[MAX_INPUT_LENGTH];
OBJ_DATA *obj;
int door;
one_argument( argument, arg );
if ( arg[0] == '\0' )
{
send_to_char( "Unlock what?\n\r", ch );
return;
}
if ( ( obj = get_obj_here( ch, arg ) ) != NULL )
{
/* 'unlock object' */
if ( obj->item_type != ITEM_CONTAINER )
{ send_to_char( "That's not a container.\n\r", ch ); return; }
if ( !IS_SET(obj->value[1], CONT_CLOSED) )
{ send_to_char( "It's not closed.\n\r", ch ); return; }
if ( obj->value[2] < 0 )
{ send_to_char( "It can't be unlocked.\n\r", ch ); return; }
if ( !has_key( ch, obj->value[2] ) )
{ send_to_char( "You lack the key.\n\r", ch ); return; }
if ( !IS_SET(obj->value[1], CONT_LOCKED) )
{ send_to_char( "It's already unlocked.\n\r", ch ); return; }
REMOVE_BIT(obj->value[1], CONT_LOCKED);
send_to_char( "*Click*\n\r", ch );
act( "$n unlocks $p.", ch, obj, NULL, TO_ROOM );
return;
}
if ( ( door = find_door( ch, arg ) ) >= 0 )
{
/* 'unlock door' */
ROOM_INDEX_DATA *to_room;
EXIT_DATA *pexit;
EXIT_DATA *pexit_rev;
pexit = ch->in_room->exit[door];
if ( !IS_SET(pexit->exit_info, EX_CLOSED) )
{ send_to_char( "It's not closed.\n\r", ch ); return; }
if ( pexit->key < 0 )
{ send_to_char( "It can't be unlocked.\n\r", ch ); return; }
if ( !has_key( ch, pexit->key) )
{ send_to_char( "You lack the key.\n\r", ch ); return; }
if ( !IS_SET(pexit->exit_info, EX_LOCKED) )
{ send_to_char( "It's already unlocked.\n\r", ch ); return; }
REMOVE_BIT(pexit->exit_info, EX_LOCKED);
send_to_char( "*Click*\n\r", ch );
act( "$n unlocks the $d.", ch, NULL, pexit->keyword, TO_ROOM );
/* unlock the other side */
if ( ( to_room = pexit->u1.to_room ) != NULL
&& ( pexit_rev = to_room->exit[rev_dir[door]] ) != NULL
&& pexit_rev->u1.to_room == ch->in_room )
{
REMOVE_BIT( pexit_rev->exit_info, EX_LOCKED );
}
}
return;
}
void do_pick( CHAR_DATA *ch, char *argument )
{
char arg[MAX_INPUT_LENGTH];
CHAR_DATA *gch;
OBJ_DATA *obj;
int door;
one_argument( argument, arg );
if ( arg[0] == '\0' )
{
send_to_char( "Pick what?\n\r", ch );
return;
}
WAIT_STATE( ch, skill_table[gsn_pick_lock].beats );
/* look for guards */
for ( gch = ch->in_room->people; gch; gch = gch->next_in_room )
{
if ( IS_NPC(gch) && IS_AWAKE(gch) && ch->level + 5 < gch->level )
{
act( "$N is standing too close to the lock.",
ch, NULL, gch, TO_CHAR );
return;
}
}
if ( !IS_NPC(ch) && number_percent( ) > ch->pcdata->learned[gsn_pick_lock] )
{
send_to_char( "You failed.\n\r", ch);
check_improve(ch,gsn_pick_lock,FALSE,2);
return;
}
if ( ( obj = get_obj_here( ch, arg ) ) != NULL )
{
/* 'pick object' */
if ( obj->item_type != ITEM_CONTAINER )
{ send_to_char( "That's not a container.\n\r", ch ); return; }
if ( !IS_SET(obj->value[1], CONT_CLOSED) )
{ send_to_char( "It's not closed.\n\r", ch ); return; }
if ( obj->value[2] < 0 )
{ send_to_char( "It can't be unlocked.\n\r", ch ); return; }
if ( !IS_SET(obj->value[1], CONT_LOCKED) )
{ send_to_char( "It's already unlocked.\n\r", ch ); return; }
if ( IS_SET(obj->value[1], CONT_PICKPROOF) )
{ send_to_char( "You failed.\n\r", ch ); return; }
REMOVE_BIT(obj->value[1], CONT_LOCKED);
send_to_char( "*Click*\n\r", ch );
check_improve(ch,gsn_pick_lock,TRUE,2);
act( "$n picks $p.", ch, obj, NULL, TO_ROOM );
return;
}
if ( ( door = find_door( ch, arg ) ) >= 0 )
{
/* 'pick door' */
ROOM_INDEX_DATA *to_room;
EXIT_DATA *pexit;
EXIT_DATA *pexit_rev;
pexit = ch->in_room->exit[door];
if ( !IS_SET(pexit->exit_info, EX_CLOSED) && !IS_IMMORTAL(ch))
{ send_to_char( "It's not closed.\n\r", ch ); return; }
if ( pexit->key < 0 && !IS_IMMORTAL(ch))
{ send_to_char( "It can't be picked.\n\r", ch ); return; }
if ( !IS_SET(pexit->exit_info, EX_LOCKED) )
{ send_to_char( "It's already unlocked.\n\r", ch ); return; }
if ( IS_SET(pexit->exit_info, EX_PICKPROOF) && !IS_IMMORTAL(ch))
{ send_to_char( "You failed.\n\r", ch ); return; }
REMOVE_BIT(pexit->exit_info, EX_LOCKED);
send_to_char( "*Click*\n\r", ch );
act( "$n picks the $d.", ch, NULL, pexit->keyword, TO_ROOM );
check_improve(ch,gsn_pick_lock,TRUE,2);
/* pick the other side */
if ( ( to_room = pexit->u1.to_room ) != NULL
&& ( pexit_rev = to_room->exit[rev_dir[door]] ) != NULL
&& pexit_rev->u1.to_room == ch->in_room )
{
REMOVE_BIT( pexit_rev->exit_info, EX_LOCKED );
}
}
return;
}
void do_stand( CHAR_DATA *ch, char *argument )
{
char buf[MAX_STRING_LENGTH];
switch ( ch->position )
{
case POS_SLEEPING:
if ( IS_AFFECTED(ch, AFF_SLEEP) )
{ send_to_char( "You can't wake up!\n\r", ch ); return; }
send_to_char( "You wake and stand up.\n\r", ch );
act( "$n wakes and stands up.", ch, NULL, NULL, TO_ROOM );
ch->position = POS_STANDING;
do_look( ch, "auto");
if (ch->pcdata)
{
if (ch->pcdata->message != NULL) {
sprintf(buf, "You have `W%d message%s`w waiting, type `Wmessages`w to read them.\n\r",
ch->pcdata->messages, (ch->pcdata->messages > 1) ? "s" : "" );
send_to_char(buf, ch);
}
}
break;
case POS_RESTING: case POS_SITTING:
send_to_char( "You stand up.\n\r", ch );
act( "$n stands up.", ch, NULL, NULL, TO_ROOM );
ch->position = POS_STANDING;
break;
case POS_STANDING:
send_to_char( "You are already standing.\n\r", ch );
break;
case POS_FIGHTING:
send_to_char( "You are already fighting!\n\r", ch );
break;
}
return;
}
void do_rest( CHAR_DATA *ch, char *argument )
{
switch ( ch->position )
{
case POS_SLEEPING:
if ( IS_AFFECTED(ch,AFF_SLEEP))
{ send_to_char("You can't wake up!\n\r",ch); return; }
send_to_char( "You wake up and start resting.\n\r", ch );
act ("$n wakes up and starts resting.",ch,NULL,NULL,TO_ROOM);
ch->position = POS_RESTING;
break;
case POS_RESTING:
send_to_char( "You are already resting.\n\r", ch );
break;
case POS_STANDING:
send_to_char( "You rest.\n\r", ch );
act( "$n sits down and rests.", ch, NULL, NULL, TO_ROOM );
ch->position = POS_RESTING;
break;
case POS_SITTING:
send_to_char("You rest.\n\r",ch);
act("$n rests.",ch,NULL,NULL,TO_ROOM);
ch->position = POS_RESTING;
break;
case POS_FIGHTING:
send_to_char( "You are already fighting!\n\r", ch );
break;
}
return;
}
void do_sit (CHAR_DATA *ch, char *argument )
{
switch (ch->position)
{
case POS_SLEEPING:
if ( IS_AFFECTED(ch,AFF_SLEEP))
{ send_to_char("You can't wake up!\n\r",ch); return; }
send_to_char("You wake up.\n\r",ch);
act("$n wakes and sits up.\n\r",ch,NULL,NULL,TO_ROOM);
ch->position = POS_SITTING;
break;
case POS_RESTING:
send_to_char("You stop resting.\n\r",ch);
ch->position = POS_SITTING;
break;
case POS_SITTING:
send_to_char("You are already sitting down.\n\r",ch);
break;
case POS_FIGHTING:
send_to_char("Maybe you should finish this fight first?\n\r",ch);
break;
case POS_STANDING:
send_to_char("You sit down.\n\r",ch);
act("$n sits down on the ground.\n\r",ch,NULL,NULL,TO_ROOM);
ch->position = POS_SITTING;
break;
}
return;
}
void do_sleep( CHAR_DATA *ch, char *argument )
{
switch ( ch->position )
{
case POS_SLEEPING:
send_to_char( "You are already sleeping.\n\r", ch );
break;
case POS_RESTING:
case POS_SITTING:
case POS_STANDING:
send_to_char( "You go to sleep. Messages are being recorded.\n\r", ch );
act( "$n goes to sleep.", ch, NULL, NULL, TO_ROOM );
ch->position = POS_SLEEPING;
break;
case POS_FIGHTING:
send_to_char( "You are already fighting!\n\r", ch );
break;
}
return;
}
void do_wake( CHAR_DATA *ch, char *argument )
{
char arg[MAX_INPUT_LENGTH];
char buf[MAX_INPUT_LENGTH];
CHAR_DATA *victim;
one_argument( argument, arg );
if ( arg[0] == '\0' )
{ do_stand( ch, argument ); return; }
if ( !IS_AWAKE(ch) )
{ send_to_char( "You are asleep yourself!\n\r", ch ); return; }
if ( ( victim = get_char_room( ch, arg ) ) == NULL )
{ send_to_char( "They aren't here.\n\r", ch ); return; }
if ( IS_AWAKE(victim) )
{ act( "$N is already awake.", ch, NULL, victim, TO_CHAR ); return; }
if ( IS_AFFECTED(victim, AFF_SLEEP) )
{ act( "You can't wake $M!", ch, NULL, victim, TO_CHAR ); return; }
victim->position = POS_STANDING;
act( "You wake $M.", ch, NULL, victim, TO_CHAR );
act( "$n wakes you.", ch, NULL, victim, TO_VICT );
if (victim->pcdata)
{
if (victim->pcdata->message != NULL) {
sprintf(buf, "You have `W%d message%s`w waiting, type `Wmessages`w to read them.\n\r",
victim->pcdata->messages, (victim->pcdata->messages > 1) ? "s" : "" );
send_to_char(buf, victim);
}
}
return;
}
void do_sneak( CHAR_DATA *ch, char *argument )
{
AFFECT_DATA af;
send_to_char( "You attempt to move silently.\n\r", ch );
affect_strip( ch, gsn_sneak );
if ( IS_NPC(ch) || number_percent( ) < ch->pcdata->learned[gsn_sneak] )
{
check_improve(ch,gsn_sneak,TRUE,3);
af.type = gsn_sneak;
af.level = ch->level;
af.duration = ch->level;
af.location = APPLY_NONE;
af.modifier = 0;
af.bitvector = AFF_SNEAK;
affect_to_char( ch, &af );
}
else
check_improve(ch,gsn_sneak,FALSE,3);
return;
}
void do_hide( CHAR_DATA *ch, char *argument )
{
send_to_char( "You attempt to hide.\n\r", ch );
if ( IS_AFFECTED(ch, AFF_HIDE) )
REMOVE_BIT(ch->affected_by, AFF_HIDE);
if ( IS_NPC(ch) || number_percent( ) < ch->pcdata->learned[gsn_hide] )
{
SET_BIT(ch->affected_by, AFF_HIDE);
check_improve(ch,gsn_hide,TRUE,3);
}
else
check_improve(ch,gsn_hide,FALSE,3);
return;
}
/*
* Contributed by Alander.
*/
void do_visible( CHAR_DATA *ch, char *argument )
{
affect_strip ( ch, gsn_invis );
affect_strip ( ch, gsn_mass_invis );
affect_strip ( ch, gsn_sneak );
REMOVE_BIT ( ch->affected_by, AFF_HIDE );
REMOVE_BIT ( ch->affected_by, AFF_INVISIBLE );
REMOVE_BIT ( ch->affected_by, AFF_SNEAK );
send_to_char( "Ok.\n\r", ch );
return;
}
void do_recall( CHAR_DATA *ch, char *argument )
{
char buf[MAX_STRING_LENGTH];
CHAR_DATA *victim;
ROOM_INDEX_DATA *location;
if (IS_NPC(ch) && !IS_SET(ch->act,ACT_PET))
{
send_to_char("Only players can recall.\n\r",ch);
return;
}
act( "$n prays for transportation!", ch, 0, 0, TO_ROOM );
if (!IS_NPC(ch))
{
if ( ch->pcdata->recall_room == NULL)
{
ch->pcdata->recall_room = get_room_index( ROOM_VNUM_TEMPLE);
}
location = ch->pcdata->recall_room;
}
else
{
location = ch->master->pcdata->recall_room;
}
if ( ch->in_room == location )
{
send_to_char( "Look around, look familiar?\n\r", ch);
return;
}
if ( IS_SET(ch->in_room->room_flags, ROOM_NO_RECALL)
|| IS_AFFECTED(ch, AFF_CURSE) )
{
send_to_char( "The gods have forsaken you.\n\r", ch );
return;
}
if ( ( victim = ch->fighting ) != NULL )
{
int lose,skill;
if (IS_NPC(ch))
skill = 40 + ch->level;
else
skill = ch->pcdata->learned[gsn_recall];
if ( number_percent() < 80 * skill / 100 )
{
check_improve(ch,gsn_recall,FALSE,6);
WAIT_STATE( ch, 4 );
sprintf( buf, "You failed!.\n\r");
send_to_char( buf, ch );
return;
}
lose = 0.05 * exp_per_level(ch, ch->pcdata->points);
gain_exp( ch, 0 - lose );
check_improve(ch,gsn_recall,TRUE,4);
sprintf( buf, "You recall from combat! You lose %d exps.\n\r", lose );
send_to_char( buf, ch );
stop_fighting( ch, TRUE );
}
ch->move /= 2;
send_to_char("You pray to the gods for transportation!", ch);
act( "$n disappears.", ch, NULL, NULL, TO_ROOM );
char_from_room( ch );
char_to_room( ch, location );
act( "$n appears in the room.", ch, NULL, NULL, TO_ROOM );
do_look( ch, "auto" );
if (ch->pet != NULL)
do_recall(ch->pet,"");
return;
}
void do_train( CHAR_DATA *ch, char *argument )
{
char buf[MAX_STRING_LENGTH];
CHAR_DATA *mob;
sh_int stat = - 1;
char *pOutput = NULL;
int cost;
if ( IS_NPC(ch) )
return;
/*
* Check for trainer.
*/
for ( mob = ch->in_room->people; mob; mob = mob->next_in_room )
{
if ( IS_NPC(mob) && IS_SET(mob->act, ACT_TRAIN) )
break;
}
if ( mob == NULL )
{
send_to_char( "You can't do that here.\n\r", ch );
return;
}
if ( argument[0] == '\0' )
{
sprintf( buf, "You have %d training sessions.\n\r", ch->train );
send_to_char( buf, ch );
argument = "foo";
}
cost = 1;
if ( !str_cmp( argument, "str" ) )
{
if ( class_table[ch->class].attr_prime == STAT_STR )
cost = 1;
stat = STAT_STR;
pOutput = "strength";
}
else if ( !str_cmp( argument, "int" ) )
{
if ( class_table[ch->class].attr_prime == STAT_INT )
cost = 1;
stat = STAT_INT;
pOutput = "intelligence";
}
else if ( !str_cmp( argument, "wis" ) )
{
if ( class_table[ch->class].attr_prime == STAT_WIS )
cost = 1;
stat = STAT_WIS;
pOutput = "wisdom";
}
else if ( !str_cmp( argument, "dex" ) )
{
if ( class_table[ch->class].attr_prime == STAT_DEX )
cost = 1;
stat = STAT_DEX;
pOutput = "dexterity";
}
else if ( !str_cmp( argument, "con" ) )
{
if ( class_table[ch->class].attr_prime == STAT_CON )
cost = 1;
stat = STAT_CON;
pOutput = "constitution";
}
else if ( !str_cmp(argument, "hp" ) )
cost = 1;
else if ( !str_cmp(argument, "mana" ) )
cost = 1;
else
{
strcpy( buf, "You can train:" );
if ( ch->perm_stat[STAT_STR] < get_max_train(ch,STAT_STR))
strcat( buf, " str" );
if ( ch->perm_stat[STAT_INT] < get_max_train(ch,STAT_INT))
strcat( buf, " int" );
if ( ch->perm_stat[STAT_WIS] < get_max_train(ch,STAT_WIS))
strcat( buf, " wis" );
if ( ch->perm_stat[STAT_DEX] < get_max_train(ch,STAT_DEX))
strcat( buf, " dex" );
if ( ch->perm_stat[STAT_CON] < get_max_train(ch,STAT_CON))
strcat( buf, " con" );
strcat( buf, " hp mana");
if ( buf[strlen(buf)-1] != ':' )
{
strcat( buf, ".\n\r" );
send_to_char( buf, ch );
}
else
{
/*
* This message dedicated to Jordan ... you big stud!
*/
act( "You have nothing left to train, you $T!",
ch, NULL,
ch->sex == SEX_MALE ? "big stud" :
ch->sex == SEX_FEMALE ? "hot babe" :
"wild thing",
TO_CHAR );
}
return;
}
if (!str_cmp("hp",argument))
{
if ( cost > ch->train )
{
send_to_char( "You don't have enough training sessions.\n\r", ch );
return;
}
ch->train -= cost;
ch->pcdata->perm_hit += 10;
ch->max_hit += 10;
ch->hit +=10;
act( "Your durability increases!",ch,NULL,NULL,TO_CHAR);
act( "$n's durability increases!",ch,NULL,NULL,TO_ROOM);
return;
}
if (!str_cmp("mana",argument))
{
if ( cost > ch->train )
{
send_to_char( "You don't have enough training sessions.\n\r", ch );
return;
}
ch->train -= cost;
ch->pcdata->perm_mana += 10;
ch->max_mana += 10;
ch->mana += 10;
act( "Your power increases!",ch,NULL,NULL,TO_CHAR);
act( "$n's power increases!",ch,NULL,NULL,TO_ROOM);
return;
}
if ( ch->perm_stat[stat] >= get_max_train(ch,stat) )
{
act( "Your $T is already at maximum.", ch, NULL, pOutput, TO_CHAR );
return;
}
if ( cost > ch->train )
{
send_to_char( "You don't have enough training sessions.\n\r", ch );
return;
}
ch->train -= cost;
ch->perm_stat[stat] += 1;
act( "Your $T increases!", ch, NULL, pOutput, TO_CHAR );
act( "$n's $T increases!", ch, NULL, pOutput, TO_ROOM );
return;
}
bool check_web( CHAR_DATA *ch)
{
AFFECT_DATA *af;
int chance;
int orig_dur;
if IS_IMMORTAL(ch)
return TRUE;
af = affect_find(ch->affected , skill_lookup("web") );
orig_dur = (af->level / 3);
chance = (get_curr_stat(ch,STAT_STR) + (ch->level / 4));
if (af->duration < (orig_dur / 9))
chance += 20;
if (af->duration > (orig_dur / 3))
chance -= 20;
if (number_percent() < chance)
return TRUE;
return FALSE;
}
void do_beacon( CHAR_DATA *ch )
{
ch->pcdata->recall_room = ch->in_room;
send_to_char( "Beacon set.\n\r", ch );
return;
}
bool can_go( CHAR_DATA *ch, int dir )
{
ROOM_INDEX_DATA *room;
EXIT_DATA *exit;
if ( !(room = ch->in_room) )
return FALSE;
if ( !(exit = ch->in_room->exit[dir]) )
return FALSE;
if ( !exit->u1.to_room )
return FALSE;
if ( !IS_SAME_AREA(room, exit->u1.to_room) )
return FALSE;
#ifdef TRACK_THROUGH_DOORS
if ( IS_CLOSED(room, dir) )
return FALSE;
#endif
return TRUE;
}
void track_enqueue(ROOM_INDEX_DATA *room, char dir)
{
struct track_queue_struct *curr;
curr = alloc_mem( sizeof( *curr ) );
curr->room = room;
curr->dir = dir;
curr->next = NULL;
if (queue_tail)
{
queue_tail->next = curr;
queue_tail = curr;
}
else
queue_head = queue_tail = curr;
}
void track_dequeue(void)
{
struct track_queue_struct *curr;
curr = queue_head;
if (!(queue_head = queue_head->next))
queue_tail = NULL;
free_mem(curr,sizeof (*curr));
}
void track_clear_queue(void)
{
while (queue_head)
track_dequeue();
}
/* find_first_step: given a source room and a target room, find the first
* step on the shortest path from the source to the target.
*
* Intended usage: in mobile_activity, give a mob a dir to go if they're
* tracking another mob or a PC. Or, a 'track' skill for PCs.
*/
int find_first_step(ROOM_INDEX_DATA *src, ROOM_INDEX_DATA *target)
{
int curr_dir;
ROOM_INDEX_DATA *curr_room;
int vnum;
if (!src || !target)
{
bug("Illegal value passed to find_first_step (track.c)",0);
return TRACK_ERROR;
}
if (src == target)
return TRACK_ALREADY_THERE;
/* clear marks first */
for (vnum = src->area->lvnum; vnum!=src->area->uvnum+1; vnum++)
{
if ((curr_room = get_room_index(vnum))!=NULL) UNMARK(curr_room);
}
MARK(src);
/* first, enqueue the first steps, saving which direction we're going. */
for (curr_dir = 0; curr_dir < 6; curr_dir++)
if (VALID_EDGE(src, curr_dir))
{
MARK(TOROOM(src, curr_dir));
track_enqueue(TOROOM(src, curr_dir), curr_dir);
}
/* now, do the track. */
while (queue_head)
{
if (queue_head->room == target)
{
curr_dir = queue_head->dir;
track_clear_queue();
return curr_dir;
}
else
{
for (curr_dir = 0; curr_dir < 6; curr_dir++)
if (VALID_EDGE(queue_head->room, curr_dir))
{
MARK(TOROOM(queue_head->room, curr_dir));
track_enqueue(TOROOM(queue_head->room, curr_dir),queue_head->dir);
}
track_dequeue();
}
}
return TRACK_NO_PATH;
}
/************************************************************************
* Functions and Commands which use the above fns *
************************************************************************/
void do_track( CHAR_DATA *ch, char *argument )
{
char buf[MAX_STRING_LENGTH];
char arg[MAX_INPUT_LENGTH];
CHAR_DATA *vict;
int dir;
const char *dir_text[]={"north","east","south","west","up","down"};
one_argument(argument, arg);
if (!*arg)
{
send_to_char( "Whom are you trying to track?\n\r", ch);
return;
}
if (!(vict = get_char_world(ch, arg)))
{
send_to_char( "You can't find them.\n\r", ch);
return;
}
dir = find_first_step(ch->in_room, vict->in_room);
switch(dir)
{
case TRACK_ERROR:
send_to_char( "Hmm.. something seems to be wrong.\n\r", ch);
break;
case TRACK_ALREADY_THERE:
send_to_char( "You're already in the same room!!\n\r", ch);
break;
case TRACK_NO_PATH:
sprintf(buf, "You can't sense a trail to %s from here.\n\r",
PERS(vict, ch));
send_to_char( buf, ch);
break;
default:
/* if you want to make this into a skill instead of a command,
the next few lines make it give you a random direction if you
fail the random skill roll.
*/
#ifdef TRACK_IS_SKILL
{
int counter;
if(!IS_NPC(ch) && number_percent() < ch->pcdata->learned[gsn_track])
for( counter = 0; counter < 50; counter++ )
{
dir = number_door();
if ( can_go( ch, dir ) )
break;
dir = -1;
}
else
update_skpell( ch, gsn_track );
if ( dir < 0 )
{
sprintf(buf, "You can't sense a trail to %s from here.\n\r",
PERS(vict,ch) );
send_to_char( buf, ch );
return;
}
}
#endif
sprintf(buf, "You sense a trail %s from here!\n\r", dir_text[dir]);
send_to_char( buf, ch);
break;
}
}